#
#
# patch "cmd_netsync.cc"
#  from [5144c2eccea81d786251eb0a6f2469731b5fff95]
#    to [f521c38b701d44d4e650c1c2ce1ff3291aeb1f2f]
# 
# patch "network/connection_info.cc"
#  from [ca442d99d973be6e4b5d6cecdd986b419896c389]
#    to [7ce0811e2070b448da20d59f881192a9285ca467]
# 
# patch "network/connection_info.hh"
#  from [81c9d8dd8e2463a2eb181df6121356e3f0bbf6ff]
#    to [eec1ebb3e3d8de7755a8a65f9cae6440518c93b6]
# 
# patch "network/netsync_session.cc"
#  from [69644079e086b89e8318bb9dc9a1e830fde9b180]
#    to [ac76090394d359b49edc3e3d6a4ed7784b4191a2]
# 
# patch "network/netsync_session.hh"
#  from [e5483827d8db0964dabed6565fddf1713f701a7d]
#    to [9923bf206a2dd21156b3b2d09aaf09beb45edc39]
#
============================================================
--- cmd_netsync.cc	5144c2eccea81d786251eb0a6f2469731b5fff95
+++ cmd_netsync.cc	f521c38b701d44d4e650c1c2ce1ff3291aeb1f2f
@@ -278,31 +278,31 @@ void print_dryrun_info(protocol_role rol
 {
   if (role != source_role)
     {
-      if (info->client.keys_in.can_have_more_than_min)
+      if (info->keys_in.can_have_more_than_min)
         {
           P(F("would receive %d revisions, %d certs, and at least %d keys")
-            % info->client.revs_in.min_count
-            % info->client.certs_in.min_count
-            % info->client.keys_in.min_count);
+            % info->revs_in.min_count
+            % info->certs_in.min_count
+            % info->keys_in.min_count);
         }
       else
         {
           P(F("would receive %d revisions, %d certs, and %d keys")
-            % info->client.revs_in.min_count
-            % info->client.certs_in.min_count
-            % info->client.keys_in.min_count);
+            % info->revs_in.min_count
+            % info->certs_in.min_count
+            % info->keys_in.min_count);
         }
     }
   if (role != sink_role)
     {
       P(F("would send %d certs and %d keys")
-        % info->client.certs_out.min_count
-        % info->client.keys_out.min_count);
+        % info->certs_out.min_count
+        % info->keys_out.min_count);
       P(F("would send %d revisions:")
-        % info->client.revs_out.min_count);
+        % info->revs_out.min_count);
       map<branch_name, int> branch_counts;
-      for (set<revision_id>::const_iterator i = info->client.revs_out.items.begin();
-           i != info->client.revs_out.items.end(); ++i)
+      for (vector<revision_id>::const_iterator i = info->revs_out.items.begin();
+           i != info->revs_out.items.end(); ++i)
         {
           set<branch_name> my_branches;
           project.get_revision_branches(*i, my_branches);
============================================================
--- network/netsync_session.cc	69644079e086b89e8318bb9dc9a1e830fde9b180
+++ network/netsync_session.cc	ac76090394d359b49edc3e3d6a4ed7784b4191a2
@@ -106,6 +106,9 @@ netsync_session::netsync_session(session
   rev_enumerator(project, *this),
   initiated_by_server(initiated_by_server)
 {
+  if (!conn_info)
+    conn_info = netsync_connection_info::create_empty();
+
   for (vector<external_key_name>::const_iterator i = opts.keys_to_push.begin();
        i != opts.keys_to_push.end(); ++i)
     {
@@ -140,11 +143,11 @@ void netsync_session::on_end(size_t iden
 
   vector<cert> unattached_written_certs;
   map<revision_id, vector<cert> > rev_written_certs;
-  for (vector<revision_id>::iterator i = written_revisions.begin();
-       i != written_revisions.end(); ++i)
+  for (vector<revision_id>::const_iterator i = conn_info->revs_in.items.begin();
+       i != conn_info->revs_in.items.end(); ++i)
     rev_written_certs.insert(make_pair(*i, vector<cert>()));
-  for (vector<cert>::iterator i = written_certs.begin();
-       i != written_certs.end(); ++i)
+  for (vector<cert>::const_iterator i = conn_info->certs_in.items.begin();
+       i != conn_info->certs_in.items.end(); ++i)
     {
       map<revision_id, vector<cert> >::iterator j;
       j = rev_written_certs.find(revision_id(i->ident));
@@ -154,14 +157,14 @@ void netsync_session::on_end(size_t iden
         j->second.push_back(*i);
     }
 
-  if (!written_keys.empty()
-      || !written_revisions.empty()
-      || !written_certs.empty())
+  if (!conn_info->revs_in.items.empty()
+      || !conn_info->keys_in.items.empty()
+      || !conn_info->certs_in.items.empty())
     {
 
       //Keys
-      for (vector<key_id>::iterator i = written_keys.begin();
-           i != written_keys.end(); ++i)
+      for (vector<key_id>::const_iterator i = conn_info->keys_in.items.begin();
+           i != conn_info->keys_in.items.end(); ++i)
         {
           key_identity_info identity;
           identity.id = *i;
@@ -170,8 +173,8 @@ void netsync_session::on_end(size_t iden
         }
 
       //Revisions
-      for (vector<revision_id>::iterator i = written_revisions.begin();
-           i != written_revisions.end(); ++i)
+      for (vector<revision_id>::const_iterator i = conn_info->revs_in.items.begin();
+           i != conn_info->revs_in.items.end(); ++i)
         {
           vector<cert> & ctmp(rev_written_certs[*i]);
           set<pair<key_identity_info, pair<cert_name, cert_value> > > certs;
@@ -202,18 +205,18 @@ void netsync_session::on_end(size_t iden
         }
     }
 
-  if (!sent_keys.empty()
-      || !sent_revisions.empty()
-      || !sent_certs.empty())
+  if (!conn_info->keys_out.items.empty()
+      || !conn_info->revs_out.items.empty()
+      || !conn_info->certs_out.items.empty())
     {
 
       vector<cert> unattached_sent_certs;
       map<revision_id, vector<cert> > rev_sent_certs;
-      for (vector<revision_id>::iterator i = sent_revisions.begin();
-           i != sent_revisions.end(); ++i)
+      for (vector<revision_id>::const_iterator i = conn_info->revs_out.items.begin();
+           i != conn_info->revs_out.items.end(); ++i)
         rev_sent_certs.insert(make_pair(*i, vector<cert>()));
-      for (vector<cert>::iterator i = sent_certs.begin();
-           i != sent_certs.end(); ++i)
+      for (vector<cert>::const_iterator i = conn_info->certs_out.items.begin();
+           i != conn_info->certs_out.items.end(); ++i)
         {
           map<revision_id, vector<cert> >::iterator j;
           j = rev_sent_certs.find(revision_id(i->ident));
@@ -224,8 +227,8 @@ void netsync_session::on_end(size_t iden
         }
 
       //Keys
-      for (vector<key_id>::iterator i = sent_keys.begin();
-           i != sent_keys.end(); ++i)
+      for (vector<key_id>::const_iterator i = conn_info->keys_out.items.begin();
+           i != conn_info->keys_out.items.end(); ++i)
         {
           key_identity_info identity;
           identity.id = *i;
@@ -234,8 +237,8 @@ void netsync_session::on_end(size_t iden
         }
 
       //Revisions
-      for (vector<revision_id>::iterator i = sent_revisions.begin();
-           i != sent_revisions.end(); ++i)
+      for (vector<revision_id>::const_iterator i = conn_info->revs_out.items.begin();
+           i != conn_info->revs_out.items.end(); ++i)
         {
           vector<cert> & ctmp(rev_sent_certs[*i]);
           set<pair<key_identity_info, pair<cert_name, cert_value> > > certs;
@@ -331,7 +334,7 @@ netsync_session::note_rev(revision_id co
   data tmp;
   write_revision(rs, tmp);
   queue_data_cmd(revision_item, rev.inner(), tmp());
-  sent_revisions.push_back(rev);
+  conn_info->revs_out.add_item(rev);
 }
 
 void
@@ -354,7 +357,7 @@ netsync_session::note_cert(id const & i)
       c.marshal_for_netio_v6(keyname, str);
     }
   queue_data_cmd(cert_item, i, str);
-  sent_certs.push_back(c);
+  conn_info->certs_out.add_item(c);
 }
 
 
@@ -445,16 +448,16 @@ netsync_session::dry_run_finished() cons
     && cert_refiner.done
     && dry_run_keys_refined;
 
-  if (all && conn_info)
+  if (all)
     {
-      conn_info->client.revs_in.set_count(rev_refiner.items_to_receive, false);
-      conn_info->client.certs_in.set_count(cert_refiner.items_to_receive, false);
-      conn_info->client.keys_in.set_count(key_refiner.min_items_to_receive,
-                                          key_refiner.may_receive_more_than_min);
+      conn_info->revs_in.set_count(rev_refiner.items_to_receive, false);
+      conn_info->certs_in.set_count(cert_refiner.items_to_receive, false);
+      conn_info->keys_in.set_count(key_refiner.min_items_to_receive,
+                                   key_refiner.may_receive_more_than_min);
 
-      conn_info->client.revs_out.set_items(rev_refiner.items_to_send);
-      conn_info->client.certs_out.set_count(cert_refiner.items_to_send.size(), false);
-      conn_info->client.keys_out.set_items(key_refiner.items_to_send);
+      conn_info->revs_out.set_items(rev_refiner.items_to_send);
+      conn_info->certs_out.set_count(cert_refiner.items_to_send.size(), false);
+      conn_info->keys_out.set_items(key_refiner.items_to_send);
     }
 
   return all;
@@ -888,7 +891,7 @@ netsync_session::load_data(netcmd_item_t
         project.db.get_pubkey(key_id(item), keyid, pub);
         L(FL("public key '%s' is also called '%s'") % item % keyid);
         write_pubkey(keyid, pub, out);
-        sent_keys.push_back(key_id(item));
+        conn_info->keys_out.add_item(key_id(item));
       }
       break;
 
@@ -1015,7 +1018,7 @@ netsync_session::process_data_cmd(netcmd
                                % tmp);
           }
         if (project.db.put_key(keyid, pub))
-          written_keys.push_back(key_id(item));
+          conn_info->keys_in.add_item(key_id(item));
         else
           error(error_codes::partial_transfer,
                 (F("Received duplicate key %s") % keyid).str());
@@ -1059,7 +1062,7 @@ netsync_session::process_data_cmd(netcmd
             if (! (tmp == item))
               throw bad_decode(F("hash check failed for revision cert '%s'") % hitem());
             if (project.db.put_revision_cert(c))
-              written_certs.push_back(c);
+              conn_info->certs_in.add_item(c);
           }
       }
       break;
@@ -1075,7 +1078,7 @@ netsync_session::process_data_cmd(netcmd
         revision_t rev;
         read_revision(d, rev);
         if (project.db.put_revision(revision_id(item), rev))
-          written_revisions.push_back(revision_id(item));
+          conn_info->revs_in.add_item(revision_id(item));
       }
       break;
 
============================================================
--- network/netsync_session.hh	e5483827d8db0964dabed6565fddf1713f701a7d
+++ network/netsync_session.hh	9923bf206a2dd21156b3b2d09aaf09beb45edc39
@@ -55,16 +55,6 @@ netsync_session:
   size_t revs_in, revs_out;
   size_t keys_in, keys_out;
 
-  // These are read from the server, written to the local database
-  std::vector<revision_id> written_revisions;
-  std::vector<key_id> written_keys;
-  std::vector<cert> written_certs;
-
-  // These are sent to the server
-  std::vector<revision_id> sent_revisions;
-  std::vector<key_id> sent_keys;
-  std::vector<cert> sent_certs;
-
   mutable bool set_totals;
 
   // Interface to refinement.
============================================================
--- network/connection_info.cc	ca442d99d973be6e4b5d6cecdd986b419896c389
+++ network/connection_info.cc	7ce0811e2070b448da20d59f881192a9285ca467
@@ -32,6 +32,11 @@ netsync_connection_info::netsync_connect
   client(d, o)
 { }
 
+netsync_connection_info::Client::Client()
+  : connection_successful(false),
+    db(*(database*)0) // horrible, horrible thing that needs to go away
+{ }
+
 netsync_connection_info::Client::Client(database & d, options const & o) :
   connection_successful(false),
   use_argv(false),
@@ -501,6 +506,14 @@ netsync_connection_info::setup_for_serve
         "in combination with --stdio"));
 }
 
+netsync_connection_info::netsync_connection_info() { }
+
+shared_conn_info
+netsync_connection_info::create_empty()
+{
+  return shared_conn_info(new netsync_connection_info);
+}
+
 // Local Variables:
 // mode: C++
 // fill-column: 76
============================================================
--- network/connection_info.hh	81c9d8dd8e2463a2eb181df6121356e3f0bbf6ff
+++ network/connection_info.hh	eec1ebb3e3d8de7755a8a65f9cae6440518c93b6
@@ -31,7 +31,7 @@ public:
 public:
   bool have_count;
   bool have_items;
-  std::set<item_type> items;
+  std::vector<item_type> items;
   size_t min_count;
   bool can_have_more_than_min;
 
@@ -49,7 +49,7 @@ public:
     for (typename std::set<input_type>::const_iterator i = in.begin();
          i != in.end(); ++i)
       {
-        items.insert(items.end(), item_type(*i));
+        items.push_back(item_type(*i));
       }
     min_count = items.size();
     can_have_more_than_min = false;
@@ -58,7 +58,7 @@ public:
   void add_item(item_type const & i)
   {
     have_items = true;
-    items.insert(i);
+    items.push_back(i);
 
     min_count = items.size();
     can_have_more_than_min = false;
@@ -90,10 +90,11 @@ struct netsync_connection_info
     std::istream * input_stream;
     automate_ostream * output_stream;
 
-    database db;
+    database & db;
     options opts;
 
     Client(database & d, options const & o);
+    Client();
     ~Client();
 
     void set_raw_uri(std::string const & uri);
@@ -117,14 +118,14 @@ struct netsync_connection_info
     connection_type get_connection_type() const;
 
     void set_connection_successful();
+  } client;
 
-    future_set<key_id> keys_in;
-    future_set<cert> certs_in;
-    future_set<revision_id> revs_in;
-    future_set<key_id> keys_out;
-    future_set<cert> certs_out;
-    future_set<revision_id> revs_out;
-  } client;
+  future_set<key_id> keys_in;
+  future_set<cert> certs_in;
+  future_set<revision_id> revs_in;
+  future_set<key_id> keys_out;
+  future_set<cert> certs_out;
+  future_set<revision_id> revs_out;
 
   static void
   setup_default(options const & opts,
@@ -164,7 +165,10 @@ struct netsync_connection_info
                   lua_hooks & lua,
                   shared_conn_info & info);
 
+  static shared_conn_info create_empty();
+
 private:
+  netsync_connection_info();
   netsync_connection_info(database & d, options const & o);
 
   static void