#
#
# patch "cmd_netsync.cc"
#  from [0571b71d680fc18500b38f25185ee7500402c31d]
#    to [972c9c76532e7e8c892c582b89a0a50b2ff78cc3]
# 
# patch "cmd_scgi.cc"
#  from [2f5e08cca931b6cf11cb2db732f39226fa9c5fda]
#    to [509cf28ff9b7584fecde01ba3afa9b26972ab7d8]
# 
# patch "gsync.cc"
#  from [f6a9cc944bcdc796f12ddbac612e9794c2d3732f]
#    to [b617e981d0b11cb8c5fb5ecfcb3b098948a32fc6]
# 
# patch "http_client.cc"
#  from [8f0fc91f82fe51cb0e1c650b88bae59fb61d8ed6]
#    to [fa1d82dbc9f6b2d5392a15868dfba528cad6cd5b]
# 
# patch "http_client.hh"
#  from [1d37aad6de15a308b82eebb4943c387546f607b2]
#    to [668db6f5ad1bedccb4679f10763d1432402653d4]
# 
# patch "json_io.hh"
#  from [07bdba5c2135920bb86262786926beb73f4e11c7]
#    to [d48db601ff48f7a46c17212542800d0d232de2a8]
# 
# patch "json_msgs.cc"
#  from [f7262e44e2fba14e5e8290ecffac79f8bd039cf4]
#    to [2789059ea725d4728e60e16a6f4a8bcf94d086c2]
# 
# patch "json_msgs.hh"
#  from [bec4ebb4a8903ea34c0feb53430b5e6ff0d6b165]
#    to [8c5866e4e1cdc3aa6e27dca3d2f7210d537451c3]
# 
# patch "net_common.cc"
#  from [149d1818998cabb5f1272b7661187bf6a089fb32]
#    to [619cb958333738577696c03cf41195ddd68cfef1]
# 
# patch "net_common.hh"
#  from [35e33459670654ffe1b980f0cb85058d56df2096]
#    to [d716d882f0ec7af9b09f2cbd0be82b401deb2278]
#
============================================================
--- cmd_netsync.cc	0571b71d680fc18500b38f25185ee7500402c31d
+++ cmd_netsync.cc	972c9c76532e7e8c892c582b89a0a50b2ff78cc3
@@ -440,7 +440,7 @@ CMD_NO_WORKSPACE(serve, "serve", "", CMD
         find_key(utf8(), globish("*"), globish(""), app);
 
       N(app.lua.hook_persist_phrase_ok(),
-	F("need permission to store persistent passphrase (see hook persist_phrase_ok())"));
+        F("need permission to store persistent passphrase (see hook persist_phrase_ok())"));
       require_password(app.opts.signing_key, app);
     }
   else if (!app.opts.bind_stdio)
@@ -454,9 +454,9 @@ run_gsync_protocol(utf8 const & addr,
 
 void 
 run_gsync_protocol(utf8 const & addr,
-		   globish const & include_pattern,
-		   globish const & exclude_pattern,
-		   app_state & app);
+                   globish const & include_pattern,
+                   globish const & exclude_pattern,
+                   app_state & app);
 
 CMD(gsync, "gsync", "", CMD_REF(network),
     N_("[ADDRESS[:PORTNUMBER] [PATTERN ...]]"),
============================================================
--- cmd_scgi.cc	2f5e08cca931b6cf11cb2db732f39226fa9c5fda
+++ cmd_scgi.cc	509cf28ff9b7584fecde01ba3afa9b26972ab7d8
@@ -105,16 +105,16 @@ parse_scgi(istream & in, string & data)
 static bool 
 parse_scgi(istream & in, string & data)
 {
-  
+
   if (!in.good()) return false;
-  
+
   size_t netstring_len;
   in >> netstring_len;
   if (!in.good()) return false;
 
   L(FL("scgi: netstring length: %d") % netstring_len);
   if (!eat(in, ':')) return false;
-  
+
   size_t content_length = 0;
   while (netstring_len > 0)
     {
@@ -136,7 +136,7 @@ parse_scgi(istream & in, string & data)
     }
 
   if(!eat(in, ',')) return false;
-  
+
   data.clear();
   data.reserve(content_length);
   L(FL("reading %d bytes") % content_length);
@@ -193,24 +193,24 @@ process_scgi_transaction(app_state & app
       json_io::tokenizer tok(in);
       json_io::parser p(tok);
       json_io::json_object_t obj = p.parse_object();
-      
+
       if (static_cast<bool>(obj)) 
         {
           transaction_guard guard(app.db);
           L(FL("read JSON object"));
-          
+
           json_io::json_value_t res = do_cmd(app, obj);
           if (static_cast<bool>(res))
             {
               json_io::printer out_data;
               res->write(out_data);
               L(FL("sending JSON %d-byte response") % (out_data.buf.size() + 1));
-              
+
               out << "Status: 200 OK\r\n"
                   << "Content-Length: " << (out_data.buf.size() + 1) << "\r\n"
                   << "Content-Type: application/jsonrequest\r\n"
                   << "\r\n";
-              
+
               out.write(out_data.buf.data(), out_data.buf.size());              
               out << "\n";
               out.flush();
@@ -261,12 +261,12 @@ CMD_NO_WORKSPACE(scgi,             // C
   if (app.opts.use_transport_auth)
     {
       N(app.lua.hook_persist_phrase_ok(),
-	F("need permission to store persistent passphrase (see hook persist_phrase_ok())"));
+        F("need permission to store persistent passphrase (see hook persist_phrase_ok())"));
       require_password(app.opts.signing_key, app);
     }
   else if (!app.opts.bind_stdio)
     W(F("The --no-transport-auth option is usually only used in combination with --stdio"));
-  
+
   if (app.opts.bind_stdio)
     process_scgi_transaction(app, std::cin, std::cout);
   else
@@ -280,7 +280,7 @@ CMD_NO_WORKSPACE(scgi,             // C
       // This will be true when we try to bind while using IPv6.  See comments
       // further down.
       bool try_again=false;
-      
+
       do
         {  
           try 
@@ -290,7 +290,7 @@ CMD_NO_WORKSPACE(scgi,             // C
               Netxx::Address addr(use_ipv6);
 
               add_address_names(addr, app.opts.bind_uris, constants::default_scgi_port);
-              
+
               // If we use IPv6 and the initialisation of server fails, we want
               // to try again with IPv4.  The reason is that someone may have
               // downloaded a IPv6-enabled monotone on a system that doesn't
@@ -298,13 +298,13 @@ CMD_NO_WORKSPACE(scgi,             // C
               // On failure, Netxx::NetworkException is thrown, and we catch
               // it further down.
               try_again=use_ipv6;
-              
+
               Netxx::StreamServer server(addr);
-          
+
               // If we came this far, whatever we used (IPv6 or IPv4) was
               // accepted, so we don't need to try again any more.
               try_again=false;
-              
+
               while (true)
                 {
                   Netxx::Peer peer = server.accept_connection();
============================================================
--- gsync.cc	f6a9cc944bcdc796f12ddbac612e9794c2d3732f
+++ gsync.cc	b617e981d0b11cb8c5fb5ecfcb3b098948a32fc6
@@ -91,8 +91,8 @@ do_set_union(set<revision_id> const & a,
 
 static inline void
 do_set_union(set<revision_id> const & a,
-	     set<revision_id> const & b,
-	     set<revision_id> & c)
+             set<revision_id> const & b,
+             set<revision_id> & c)
 {
   c.clear();
   set_union(a.begin(), a.end(), b.begin(), b.end(), inserter(c, c.begin()));
@@ -100,8 +100,8 @@ do_set_difference(set<revision_id> const
 
 static inline void
 do_set_difference(set<revision_id> const & a,
-		  set<revision_id> const & b,
-		  set<revision_id> & c)
+                  set<revision_id> const & b,
+                  set<revision_id> & c)
 {
   c.clear();
   set_difference(a.begin(), a.end(), b.begin(), b.end(), inserter(c, c.begin()));
@@ -110,8 +110,8 @@ inquire_about_revs(http_client & h,
 
 static void 
 inquire_about_revs(http_client & h,
-		   set<revision_id> const & query_set,
-		   set<revision_id> & theirs)
+                   set<revision_id> const & query_set,
+                   set<revision_id> & theirs)
 {
   theirs.clear();  
   json_value_t query = encode_msg_inquire(query_set);  
@@ -122,10 +122,10 @@ determine_common_core(http_client & h,
 
 static void
 determine_common_core(http_client & h,
-		      set<revision_id> const & our_revs,
-		      rev_ancestry_map const & child_to_parent_map,
-		      rev_ancestry_map const & parent_to_child_map,
-		      set<revision_id> & common_core)
+                      set<revision_id> const & our_revs,
+                      rev_ancestry_map const & child_to_parent_map,
+                      rev_ancestry_map const & parent_to_child_map,
+                      set<revision_id> & common_core)
 {
   common_core.clear();
   set<revision_id> unknown_revs = our_revs;
@@ -135,15 +135,15 @@ determine_common_core(http_client & h,
     {
       ++pass;
       set<revision_id> query_revs;
-      
+
       // Bite off a chunk of the remaining unknowns to ask about.
       set<revision_id>::const_iterator r = unknown_revs.begin();
       for (size_t i = 0; 
-	   i < constants::gsync_max_probe_set_size && r != unknown_revs.end(); 
-	   ++i, ++r)
-	{
-	  query_revs.insert(*r);
-	}
+           i < constants::gsync_max_probe_set_size && r != unknown_revs.end(); 
+           ++i, ++r)
+        {
+          query_revs.insert(*r);
+        }
 
       // Ask what they have of that chunk, form closures of the
       // positive and negative sets on our side.
@@ -154,10 +154,10 @@ determine_common_core(http_client & h,
       do_set_difference(query_revs, revs_present, revs_absent);
 
       L(FL("pass #%d: inquired about %d revs, they have %d of them, missing %d of them") 
-	% pass
-	% query_revs.size() 
-	% revs_present.size()
-	% revs_absent.size());
+        % pass
+        % query_revs.size() 
+        % revs_present.size()
+        % revs_absent.size());
 
       get_all_ancestors(revs_present, child_to_parent_map, present_ancs);
       do_set_union(revs_present, present_ancs, present_closure);
@@ -173,12 +173,12 @@ determine_common_core(http_client & h,
       do_set_difference(unknown_revs, present_closure, new_unknown);
       unknown_revs = new_unknown;
       L(FL("pass #%d: unknown set after removing %d-entry present closure: %d nodes") 
-	% pass % present_closure.size() % unknown_revs.size());
+        % pass % present_closure.size() % unknown_revs.size());
 
       do_set_difference(unknown_revs, absent_closure, new_unknown);
       unknown_revs = new_unknown;
       L(FL("pass #%d: unknown set after removing %d-entry absent closure: %d nodes") 
-	% pass % absent_closure.size() % unknown_revs.size());
+        % pass % absent_closure.size() % unknown_revs.size());
 
       // Update our total knowledge about them.
       common_core.insert(present_closure.begin(), present_closure.end());
@@ -187,7 +187,7 @@ invert_ancestry(rev_ancestry_map const &
 
 static void
 invert_ancestry(rev_ancestry_map const & in,
-		rev_ancestry_map & out)
+                rev_ancestry_map & out)
 {
   out.clear();
   for (rev_ancestry_map::const_iterator i = in.begin();
@@ -197,10 +197,10 @@ do_missing_playback(http_client & h,
 
 static void
 do_missing_playback(http_client & h,
-		    app_state & app, 
-		    set<revision_id> & core_frontier, 
-		    set<revision_id> & revs_to_push,
-		    rev_ancestry_map const & parent_to_child_map)
+                    app_state & app, 
+                    set<revision_id> & core_frontier, 
+                    set<revision_id> & revs_to_push,
+                    rev_ancestry_map const & parent_to_child_map)
 {
   // add the root revision to the frontier, so we also push
   // initial revisions.
@@ -251,22 +251,22 @@ request_missing_playback(http_client & h
 
 static void 
 request_missing_playback(http_client & h,
-			 app_state & app,
-			 set<revision_id> const & core_frontier)
+                         app_state & app,
+                         set<revision_id> const & core_frontier)
 {
-  
+
 }
 
 void
 run_gsync_protocol(utf8 const & addr,
-		   globish const & include_pattern,
-		   globish const & exclude_pattern,
-		   app_state & app)
+                   globish const & include_pattern,
+                   globish const & exclude_pattern,
+                   app_state & app)
 {
   uri u;
   parse_uri(addr(), u);
   http_client h(app, u, include_pattern, exclude_pattern);
-  
+
   bool pushing = true, pulling = true;
 
   rev_ancestry_map parent_to_child_map, child_to_parent_map;
@@ -278,9 +278,9 @@ run_gsync_protocol(utf8 const & addr,
        i != child_to_parent_map.end(); ++i)
     {
       if (!i->first.inner()().empty())
-	our_revs.insert(i->first);
+        our_revs.insert(i->first);
       if (!i->second.inner()().empty())
-	our_revs.insert(i->second);
+        our_revs.insert(i->second);
     }
 
   set<revision_id> common_core;
============================================================
--- http_client.cc	8f0fc91f82fe51cb0e1c650b88bae59fb61d8ed6
+++ http_client.cc	fa1d82dbc9f6b2d5392a15868dfba528cad6cd5b
@@ -47,9 +47,9 @@ http_client::http_client(app_state & app
 
 
 http_client::http_client(app_state & app,
-			 uri const & u, 	      
-			 globish const & include_pattern,
-			 globish const & exclude_pattern)
+                         uri const & u,               
+                         globish const & include_pattern,
+                         globish const & exclude_pattern)
   : app(app), 
     u(u), 
     include_pattern(include_pattern), 
@@ -85,17 +85,17 @@ http_client::transact_json(json_value_t 
   json_io::printer out;
   v->write(out);
   string header = (F("POST %s HTTP/1.0\r\n"
-		     "Host: %s\r\n"
-		     "Content-Length: %s\r\n"
-		     "Content-Type: application/jsonrequest\r\n"
-		     "Accept: application/jsonrequest\r\n"
-		     "Accept-Encoding: identity\r\n"
-		     "Connection: Keep-Alive\r\n"
-		     "\r\n") 
-		   % (u.path.empty() ? "/" : u.path)
-		   % u.host 
-		   % lexical_cast<string>(out.buf.size())).str();
-  
+                     "Host: %s\r\n"
+                     "Content-Length: %s\r\n"
+                     "Content-Type: application/jsonrequest\r\n"
+                     "Accept: application/jsonrequest\r\n"
+                     "Accept-Encoding: identity\r\n"
+                     "Connection: Keep-Alive\r\n"
+                     "\r\n") 
+                   % (u.path.empty() ? "/" : u.path)
+                   % u.host 
+                   % lexical_cast<string>(out.buf.size())).str();
+
   L(FL("http_client: sending request [[POST %s HTTP/1.0]]") 
     % (u.path.empty() ? "/" : u.path));
   L(FL("http_client: to [[Host: %s]]") % u.host);
@@ -131,22 +131,22 @@ http_client::parse_http_header_line(size
 
 void 
 http_client::parse_http_header_line(size_t & content_length, 
-				    bool & keepalive)
+                                    bool & keepalive)
 {
   string k, v, rest;
   (*io) >> k >> v;
   L(FL("http_client: header: [[%s %s]]") % k % v);
   std::getline(*io, rest);
-  
+
   if (k == "Content-Length:" 
       || k == "Content-length:"
       || k == "content-length:")
     content_length = lexical_cast<size_t>(v);
   else if (k == "Connection:" 
-	   || k == "connection:")
+           || k == "connection:")
     keepalive = (v == "Keep-Alive" 
-		 || v == "Keep-alive" 
-		 || v == "keep-alive");
+                 || v == "Keep-alive" 
+                 || v == "keep-alive");
 }
 
 
============================================================
--- http_client.hh	1d37aad6de15a308b82eebb4943c387546f607b2
+++ http_client.hh	668db6f5ad1bedccb4679f10763d1432402653d4
@@ -40,14 +40,14 @@ http_client
   bool open;
 
   http_client(app_state & app,
-	      uri const & u, 	      
-	      globish const & include_pattern,
-	      globish const & exclude_pattern); 
+              uri const & u,          
+              globish const & include_pattern,
+              globish const & exclude_pattern); 
 
   json_io::json_value_t transact_json(json_io::json_value_t v);
   void parse_http_status_line();
   void parse_http_header_line(size_t & content_length,
-			      bool & keepalive);
+                              bool & keepalive);
   void parse_http_response(std::string & data);
   void crlf();  
 };
============================================================
--- json_io.hh	07bdba5c2135920bb86262786926beb73f4e11c7
+++ json_io.hh	d48db601ff48f7a46c17212542800d0d232de2a8
@@ -50,7 +50,7 @@ namespace json_io
   };
 
   typedef boost::shared_ptr<json_object> json_object_t;
-  
+
   struct json_array 
     : public json_value
   {
@@ -77,7 +77,7 @@ namespace json_io
   ///////////////////////////////////////////////////////////
   // lexing
   ///////////////////////////////////////////////////////////
-    
+
   typedef enum
     {
       TOK_SYMBOL,
@@ -102,7 +102,7 @@ namespace json_io
     char c;
     input_source(std::string const & in, std::string const & nm)
       : line(1), col(1), in(in), curr(in.begin()),
-	name(nm), lookahead(0), c('\0')
+        name(nm), lookahead(0), c('\0')
     {}
 
     inline void peek()
@@ -110,9 +110,9 @@ namespace json_io
       if (LIKELY(curr != in.end()))
         // we do want to distinguish between EOF and '\xff', 
         // so we translate '\xff' to 255u
-	lookahead = widen<unsigned int,char>(*curr);
+        lookahead = widen<unsigned int,char>(*curr);
       else
-	lookahead = EOF;
+        lookahead = EOF;
     }
 
     inline void advance()
@@ -205,24 +205,24 @@ namespace json_io
         }
 
       if (is_alpha(in.lookahead))
-	{
-	  mark();
-	  while (is_alnum(in.lookahead) || in.lookahead == '_')
-	    advance();
-	  store(val);
-	  return json_io::TOK_SYMBOL;
-	}
+        {
+          mark();
+          while (is_alnum(in.lookahead) || in.lookahead == '_')
+            advance();
+          store(val);
+          return json_io::TOK_SYMBOL;
+        }
 
       else if (in.lookahead == '"')
-	{
-	  in.advance();
-	  mark();
-	  while (static_cast<char>(in.lookahead) != '"')
-	    {
-	      if (UNLIKELY(in.lookahead == EOF))
-		in.err("input stream ended in string");
-	      if (UNLIKELY(static_cast<char>(in.lookahead) == '\\'))
-		{
+        {
+          in.advance();
+          mark();
+          while (static_cast<char>(in.lookahead) != '"')
+            {
+              if (UNLIKELY(in.lookahead == EOF))
+                in.err("input stream ended in string");
+              if (UNLIKELY(static_cast<char>(in.lookahead) == '\\'))
+                {
                   // When we hit an escape, we switch from doing mark/store
                   // to a slower per-character append loop, until the end
                   // of the token.
@@ -231,7 +231,7 @@ namespace json_io
                   store(val);
 
                   // Then skip over the escape backslash.
-		  in.advance();
+                  in.advance();
 
                   // Handle the escaped char.
                   read_escape(val, static_cast<char>(in.lookahead));
@@ -262,50 +262,50 @@ namespace json_io
                   in.advance();
 
                   return json_io::TOK_STRING;
-		}
-	      advance();
-	    }
-	
-	  store(val);
+                }
+              advance();
+            }
 
-	  if (UNLIKELY(static_cast<char>(in.lookahead) != '"'))
-	    in.err("string did not end with '\"'");
-	  in.advance();
-	
-	  return json_io::TOK_STRING;
-	}
+          store(val);
+
+          if (UNLIKELY(static_cast<char>(in.lookahead) != '"'))
+            in.err("string did not end with '\"'");
+          in.advance();
+
+          return json_io::TOK_STRING;
+        }
       else if (in.lookahead == '[')
-	{
-	  in.advance();
+        {
+          in.advance();
           return json_io::TOK_LBRACKET;
         }
       else if (in.lookahead == ']')
         {
-	  in.advance();
+          in.advance();
           return json_io::TOK_RBRACKET;
         }
       else if (in.lookahead == '{')
         {
-	  in.advance();
+          in.advance();
           return json_io::TOK_LBRACE;
         }
       else if (in.lookahead == '}')
         {
-	  in.advance();
+          in.advance();
           return json_io::TOK_RBRACE;
         }
       else if (in.lookahead == ':')
         {
-	  in.advance();
+          in.advance();
           return json_io::TOK_COLON;
         }
       else if (in.lookahead == ',')
         {
-	  in.advance();
+          in.advance();
           return json_io::TOK_COMMA;
         }
       else
-	return json_io::TOK_NONE;
+        return json_io::TOK_NONE;
     }
    void err(std::string const & s);
   };
@@ -314,7 +314,7 @@ namespace json_io
   ///////////////////////////////////////////////////////////
   // parsing
   ///////////////////////////////////////////////////////////
-  
+
   struct
   parser
   {
@@ -409,7 +409,7 @@ namespace json_io
       else 
         return json_value_t();
     }
-    
+
     inline void str() { eat(json_io::TOK_STRING); }
     inline void sym() { eat(json_io::TOK_SYMBOL); }
     inline void colon() { eat(json_io::TOK_COLON); }
@@ -456,7 +456,7 @@ namespace json_io
   ///////////////////////////////////////////////////////////
   /////////////////////// building //////////////////////////
   ///////////////////////////////////////////////////////////
-  
+
   struct builder
   {
     json_value_t v;
============================================================
--- json_msgs.cc	f7262e44e2fba14e5e8290ecffac79f8bd039cf4
+++ json_msgs.cc	2789059ea725d4728e60e16a6f4a8bcf94d086c2
@@ -94,7 +94,7 @@ decode_msg_error(json_value_t val, 
 
 bool 
 decode_msg_error(json_value_t val, 
-		 std::string & note)
+                 std::string & note)
 {
   json_io::query q(val);
   note.clear();
@@ -120,7 +120,7 @@ decode_msg_inquire(json_value_t val, 
 
 bool 
 decode_msg_inquire(json_value_t val, 
-		   set<revision_id> & revs)
+                   set<revision_id> & revs)
 {
   string type, vers;
   json_io::query q(val);  
@@ -134,9 +134,9 @@ decode_msg_inquire(json_value_t val, 
         {
           std::string s;
           for (size_t i = 0; i < nargs; ++i)
-	    if (q[syms::revs][i].get(s)) 
-	      revs.insert(revision_id(s));
-	  return true;
+            if (q[syms::revs][i].get(s)) 
+              revs.insert(revision_id(s));
+          return true;
         }
     }
   return false;
@@ -164,7 +164,7 @@ decode_msg_confirm(json_value_t val, 
 
 bool 
 decode_msg_confirm(json_value_t val, 
-		   set<revision_id> & revs)
+                   set<revision_id> & revs)
 {
   string type, vers;
   json_io::query q(val);  
@@ -177,9 +177,9 @@ decode_msg_confirm(json_value_t val, 
       string tmp;
       json_io::query r = q[syms::revs];
       if (r.len(nrevs))
-	for (size_t i = 0; i < nrevs; ++i) 
-	  if (r[i].get(tmp))
-	    revs.insert(revision_id(tmp));
+        for (size_t i = 0; i < nrevs; ++i) 
+          if (r[i].get(tmp))
+            revs.insert(revision_id(tmp));
       return true;
     }
   return false;
@@ -193,7 +193,7 @@ decode_msg_get_descendants(json_value_t 
 encode_msg_get_descendants(set<revision_id> const & revs);
 bool 
 decode_msg_get_descendants(json_value_t val, 
-			   set<revision_id> & revs);
+                           set<revision_id> & revs);
 
 
 /////////////////////////////////////////////////////////////////////
@@ -204,7 +204,7 @@ decode_msg_descendants(json_value_t val,
 encode_msg_descendants(rev_ancestry_map const & parent_to_child_map);
 bool 
 decode_msg_descendants(json_value_t val, 
-		       rev_ancestry_map & parent_to_child_map);
+                       rev_ancestry_map & parent_to_child_map);
 
 
 /////////////////////////////////////////////////////////////////////
@@ -293,9 +293,9 @@ encode_msg_full_rev(revision_id const & 
 
 json_value_t 
 encode_msg_full_rev(revision_id const & rid,
-		    revision_t const & rev,
-		    set<file_delta_record> const & deltas,
-		    set<file_data_record> const & datas)
+                    revision_t const & rev,
+                    set<file_delta_record> const & deltas,
+                    set<file_data_record> const & datas)
 {
   json_io::builder b;  
   b[syms::type].str(syms::full_rev());
@@ -306,10 +306,10 @@ decode_msg_full_rev(json_value_t val, 
 
 bool 
 decode_msg_full_rev(json_value_t val, 
-		    revision_id & rid,
-		    revision_t & rev,
-		    set<file_delta_record> & deltas,
-		    set<file_data_record> & datas)
+                    revision_id & rid,
+                    revision_t & rev,
+                    set<file_delta_record> & deltas,
+                    set<file_data_record> & datas)
 {
   json_io::builder b;
   b[syms::type].str(syms::full_rev());
============================================================
--- json_msgs.hh	bec4ebb4a8903ea34c0feb53430b5e6ff0d6b165
+++ json_msgs.hh	8c5866e4e1cdc3aa6e27dca3d2f7210d537451c3
@@ -27,28 +27,28 @@ bool decode_msg_inquire(json_io::json_va
 
 json_io::json_value_t encode_msg_inquire(std::set<revision_id> const & revs);
 bool decode_msg_inquire(json_io::json_value_t val, 
-			std::set<revision_id> & revs);
+                        std::set<revision_id> & revs);
 
 json_io::json_value_t encode_msg_confirm(std::set<revision_id> const & revs);
 bool decode_msg_confirm(json_io::json_value_t val, 
-			std::set<revision_id> & revs);
+                        std::set<revision_id> & revs);
 
 json_io::json_value_t encode_msg_get_descendants(std::set<revision_id> const & start);
 bool decode_msg_get_descendants(json_io::json_value_t val, 
-				std::set<revision_id> & start);
+                                std::set<revision_id> & start);
 
 json_io::json_value_t encode_msg_descendants(rev_ancestry_map const & parent_to_child_map);
 bool decode_msg_descendants(json_io::json_value_t val, 
-			    rev_ancestry_map & parent_to_child_map);
+                            rev_ancestry_map & parent_to_child_map);
 
 json_io::json_value_t encode_msg_get_file_data(file_id const & fid);
 bool decode_msg_get_file_data(json_io::json_value_t val, file_id & fid);
 
 json_io::json_value_t encode_msg_get_file_delta(file_id const & src_id,
-						file_id const & dst_id);
+                                                file_id const & dst_id);
 bool decode_msg_get_file_delta(json_io::json_value_t val, 
-			       file_id & src_id,
-			       file_id & dst_id);
+                               file_id & src_id,
+                               file_id & dst_id);
 
 json_io::json_value_t encode_msg_get_rev(revision_id const & rid);
 bool decode_msg_get_rev(json_io::json_value_t val, revision_id & rid);
@@ -81,14 +81,14 @@ json_io::json_value_t encode_msg_full_re
 bool decode_msg_rev(json_io::json_value_t val, revision_t & rev);
 
 json_io::json_value_t encode_msg_full_rev(revision_id const & rid,
-					  revision_t const & rev,
-					  std::set<file_delta_record> const & deltas,
-					  std::set<file_data_record> const & datas);
+                                          revision_t const & rev,
+                                          std::set<file_delta_record> const & deltas,
+                                          std::set<file_data_record> const & datas);
 bool decode_msg_full_rev(json_io::json_value_t val, 
-			 revision_id & rid,
-			 revision_t & rev,
-			 std::set<file_delta_record> & deltas,
-			 std::set<file_data_record> & datas);
+                         revision_id & rid,
+                         revision_t & rev,
+                         std::set<file_delta_record> & deltas,
+                         std::set<file_data_record> & datas);
 
 // Local Variables:
 // mode: C++
============================================================
--- net_common.cc	149d1818998cabb5f1272b7661187bf6a089fb32
+++ net_common.cc	619cb958333738577696c03cf41195ddd68cfef1
@@ -35,38 +35,38 @@ add_address_names(Netxx::Address & addr,
 
 void 
 add_address_names(Netxx::Address & addr,
-		  std::list<utf8> const & addresses,
-		  Netxx::port_type default_port)
+                  std::list<utf8> const & addresses,
+                  Netxx::port_type default_port)
 {
   if (addresses.empty())
     addr.add_all_addresses(default_port);
   else
     {
       for (std::list<utf8>::const_iterator it = addresses.begin(); it != addresses.end(); ++it)
-	{
-	  const utf8 & address = *it;
-	  if (!address().empty())
-	    {
-	      size_t l_colon = address().find(':');
-	      size_t r_colon = address().rfind(':');
-	      
-	      if (l_colon == r_colon && l_colon == 0)
-		{
-		  // can't be an IPv6 address as there is only one colon
-		  // must be a : followed by a port
-		  string port_str = address().substr(1);
-		  addr.add_all_addresses(std::atoi(port_str.c_str()));
-		}
-	      else
-		addr.add_address(address().c_str(), default_port);
-	    }
-	}
+        {
+          const utf8 & address = *it;
+          if (!address().empty())
+            {
+              size_t l_colon = address().find(':');
+              size_t r_colon = address().rfind(':');
+
+              if (l_colon == r_colon && l_colon == 0)
+                {
+                  // can't be an IPv6 address as there is only one colon
+                  // must be a : followed by a port
+                  string port_str = address().substr(1);
+                  addr.add_all_addresses(std::atoi(port_str.c_str()));
+                }
+              else
+                addr.add_address(address().c_str(), default_port);
+            }
+        }
     }
 }
 
 shared_ptr<Netxx::StreamBase>
 build_stream_to_server(app_state & app,
-		       uri const & u,
+                       uri const & u,
                        globish const & include_pattern,
                        globish const & exclude_pattern,                       
                        Netxx::port_type default_port,
============================================================
--- net_common.hh	35e33459670654ffe1b980f0cb85058d56df2096
+++ net_common.hh	d716d882f0ec7af9b09f2cbd0be82b401deb2278
@@ -34,13 +34,13 @@ add_address_names(Netxx::Address & addr,
 
 void 
 add_address_names(Netxx::Address & addr,
-		  std::list<utf8> const & addresses,
-		  Netxx::port_type default_port);
+                  std::list<utf8> const & addresses,
+                  Netxx::port_type default_port);
 
 boost::shared_ptr<Netxx::StreamBase>
 build_stream_to_server(app_state & app,
-		       uri const & u,
-		       globish const & include_pattern,
+                       uri const & u,
+                       globish const & include_pattern,
                        globish const & exclude_pattern,
                        Netxx::port_type default_port,
                        Netxx::Timeout timeout);