subversion-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From stef...@apache.org
Subject svn commit: r1476675 [14/17] - in /subversion/branches/fsfs-format7: ./ build/ build/ac-macros/ build/generator/ build/generator/templates/ contrib/hook-scripts/ contrib/server-side/svncutter/ subversion/bindings/cxxhl/include/ subversion/bindings/cxxh...
Date Sat, 27 Apr 2013 21:30:43 GMT
Modified: subversion/branches/fsfs-format7/subversion/svnserve/serve.c
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/svnserve/serve.c?rev=1476675&r1=1476674&r2=1476675&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/svnserve/serve.c (original)
+++ subversion/branches/fsfs-format7/subversion/svnserve/serve.c Sat Apr 27 21:30:36 2013
@@ -191,10 +191,10 @@ log_fail_and_flush(svn_error_t *err, ser
   svn_error_t *io_err;
 
   log_server_error(err, server, conn, pool);
-  io_err = svn_ra_svn_write_cmd_failure(conn, pool, err);
+  io_err = svn_ra_svn__write_cmd_failure(conn, pool, err);
   svn_error_clear(err);
   SVN_ERR(io_err);
-  return svn_ra_svn_flush(conn, pool);
+  return svn_ra_svn__flush(conn, pool);
 }
 
 /* Log a client command. */
@@ -246,7 +246,7 @@ log_authz_denied(const char *path,
   timestr = svn_time_to_cstring(apr_time_now(), pool);
   remote_host = svn_ra_svn_conn_remote_host(conn);
 
-  line = apr_psprintf(pool, "%" APR_PID_T_FMT 
+  line = apr_psprintf(pool, "%" APR_PID_T_FMT
                       " %s %s %s %s Authorization Failed %s%s %s" APR_EOL_STR,
                       getpid(), timestr,
                       (remote_host ? remote_host : "-"),
@@ -276,7 +276,8 @@ svn_error_t *load_pwdb_config(server_bat
       pwdb_path = svn_dirent_internal_style(pwdb_path, pool);
       pwdb_path = svn_dirent_join(server->base, pwdb_path, pool);
 
-      err = svn_config_read2(&server->pwdb, pwdb_path, TRUE, FALSE, pool);
+      err = svn_config_read3(&server->pwdb, pwdb_path, TRUE,
+                             FALSE, FALSE, pool);
       if (err)
         {
           log_server_error(err, server, conn, pool);
@@ -308,29 +309,35 @@ svn_error_t *load_pwdb_config(server_bat
   return SVN_NO_ERROR;
 }
 
-/* Canonicalize ACCESS_FILE based on the type of argument.
- * SERVER baton is used to convert relative paths to absolute paths
- * rooted at the server root. */
-static const char *
-canonicalize_access_file(const char *access_file,
-                         server_baton_t *server,
-                         apr_pool_t *pool)
+/* Canonicalize *ACCESS_FILE based on the type of argument.  Results are
+ * placed in *ACCESS_FILE.  SERVER baton is used to convert relative paths to
+ * absolute paths rooted at the server root.  REPOS_ROOT is used to calculate
+ * an absolute URL for repos-relative URLs. */
+static svn_error_t *
+canonicalize_access_file(const char **access_file, server_baton_t *server,
+                         const char *repos_root, apr_pool_t *pool)
 {
-  if (svn_path_is_url(access_file))
+  if (svn_path_is_url(*access_file))
     {
-      access_file = svn_uri_canonicalize(access_file, pool);
+      *access_file = svn_uri_canonicalize(*access_file, pool);
     }
-  else if (!svn_path_is_repos_relative_url(access_file))
+  else if (svn_path_is_repos_relative_url(*access_file))
     {
-      access_file = svn_dirent_internal_style(access_file, pool);
-      access_file = svn_dirent_join(server->base, access_file, pool);
-    }
+      const char *repos_root_url;
 
-  /* We don't canonicalize repos relative urls since they get
-   * canonicalized inside svn_repos_authz_read2() when they
-   * are resolved. */
+      SVN_ERR(svn_uri_get_file_url_from_dirent(&repos_root_url, repos_root,
+                                               pool));
+      SVN_ERR(svn_path_resolve_repos_relative_url(access_file, *access_file,
+                                                  repos_root_url, pool));
+      *access_file = svn_uri_canonicalize(*access_file, pool);
+    }
+  else
+    {
+      *access_file = svn_dirent_internal_style(*access_file, pool);
+      *access_file = svn_dirent_join(server->base, *access_file, pool);
+    }
 
-  return access_file;
+  return SVN_NO_ERROR;
 }
 
 svn_error_t *load_authz_config(server_baton_t *server,
@@ -354,15 +361,18 @@ svn_error_t *load_authz_config(server_ba
       const char *case_force_val;
 
       /* Canonicalize and add the base onto the authzdb_path (if needed). */
-      authzdb_path = canonicalize_access_file(authzdb_path, server, pool);
+      err = canonicalize_access_file(&authzdb_path, server,
+                                     repos_root, pool);
 
       /* Same for the groupsdb_path if it is present. */
-      if (groupsdb_path)
-        groupsdb_path = canonicalize_access_file(groupsdb_path,
-                                                 server, pool);
+      if (groupsdb_path && !err)
+        err = canonicalize_access_file(&groupsdb_path, server,
+                                       repos_root, pool);
+
+      if (!err)
+        err = svn_repos_authz_read2(&server->authzdb, authzdb_path,
+                                    groupsdb_path, TRUE, pool);
 
-      err = svn_repos_authz_read2(&server->authzdb, authzdb_path,
-                                  groupsdb_path, TRUE, repos_root, pool);
       if (err)
         {
           log_server_error(err, server, conn, pool);
@@ -554,11 +564,11 @@ static svn_error_t *send_mechs(svn_ra_sv
                                svn_boolean_t needs_username)
 {
   if (!needs_username && get_access(b, UNAUTHENTICATED) >= required)
-    SVN_ERR(svn_ra_svn_write_word(conn, pool, "ANONYMOUS"));
+    SVN_ERR(svn_ra_svn__write_word(conn, pool, "ANONYMOUS"));
   if (b->tunnel_user && get_access(b, AUTHENTICATED) >= required)
-    SVN_ERR(svn_ra_svn_write_word(conn, pool, "EXTERNAL"));
+    SVN_ERR(svn_ra_svn__write_word(conn, pool, "EXTERNAL"));
   if (b->pwdb && get_access(b, AUTHENTICATED) >= required)
-    SVN_ERR(svn_ra_svn_write_word(conn, pool, "CRAM-MD5"));
+    SVN_ERR(svn_ra_svn__write_word(conn, pool, "CRAM-MD5"));
   return SVN_NO_ERROR;
 }
 
@@ -631,10 +641,10 @@ static svn_error_t *auth(svn_ra_svn_conn
       && b->tunnel_user && strcmp(mech, "EXTERNAL") == 0)
     {
       if (*mecharg && strcmp(mecharg, b->tunnel_user) != 0)
-        return svn_ra_svn_write_tuple(conn, pool, "w(c)", "failure",
-                                      "Requested username does not match");
+        return svn_ra_svn__write_tuple(conn, pool, "w(c)", "failure",
+                                       "Requested username does not match");
       b->user = b->tunnel_user;
-      SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "w()", "success"));
+      SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "w()", "success"));
       *success = TRUE;
       return SVN_NO_ERROR;
     }
@@ -642,7 +652,7 @@ static svn_error_t *auth(svn_ra_svn_conn
   if (get_access(b, UNAUTHENTICATED) >= required
       && strcmp(mech, "ANONYMOUS") == 0 && ! needs_username)
     {
-      SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "w()", "success"));
+      SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "w()", "success"));
       *success = TRUE;
       return SVN_NO_ERROR;
     }
@@ -655,7 +665,7 @@ static svn_error_t *auth(svn_ra_svn_conn
       return SVN_NO_ERROR;
     }
 
-  return svn_ra_svn_write_tuple(conn, pool, "w(c)", "failure",
+  return svn_ra_svn__write_tuple(conn, pool, "w(c)", "failure",
                                 "Must authenticate with listed mechanism");
 }
 
@@ -668,12 +678,12 @@ internal_auth_request(svn_ra_svn_conn_t 
   svn_boolean_t success;
   const char *mech, *mecharg;
 
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "w((!", "success"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "w((!", "success"));
   SVN_ERR(send_mechs(conn, pool, b, required, needs_username));
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!)c)", b->realm));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!)c)", b->realm));
   do
     {
-      SVN_ERR(svn_ra_svn_read_tuple(conn, pool, "w(?c)", &mech, &mecharg));
+      SVN_ERR(svn_ra_svn__read_tuple(conn, pool, "w(?c)", &mech, &mecharg));
       if (!*mech)
         break;
       SVN_ERR(auth(conn, pool, mech, mecharg, b, required, needs_username,
@@ -706,7 +716,7 @@ static svn_error_t *auth_request(svn_ra_
 static svn_error_t *trivial_auth_request(svn_ra_svn_conn_t *conn,
                                          apr_pool_t *pool, server_baton_t *b)
 {
-  return svn_ra_svn_write_cmd_response(conn, pool, "()c", "");
+  return svn_ra_svn__write_cmd_response(conn, pool, "()c", "");
 }
 
 /* Ensure that the client has the REQUIRED access by checking the
@@ -829,7 +839,7 @@ static svn_error_t *set_path(svn_ra_svn_
   svn_depth_t depth = svn_depth_infinity;
   svn_boolean_t start_empty;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "crb?(?c)?w",
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "crb?(?c)?w",
                                  &path, &rev, &start_empty, &lock_token,
                                  &depth_word));
   if (depth_word)
@@ -852,7 +862,7 @@ static svn_error_t *delete_path(svn_ra_s
   report_driver_baton_t *b = baton;
   const char *path;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "c", &path));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "c", &path));
   path = svn_relpath_canonicalize(path, pool);
   if (!b->err)
     b->err = svn_repos_delete_path(b->report_baton, path, pool);
@@ -869,7 +879,7 @@ static svn_error_t *link_path(svn_ra_svn
   /* Default to infinity, for old clients that don't send depth. */
   svn_depth_t depth = svn_depth_infinity;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "ccrb?(?c)?w",
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "ccrb?(?c)?w",
                                  &path, &url, &rev, &start_empty,
                                  &lock_token, &depth_word));
 
@@ -974,7 +984,7 @@ static svn_error_t *accept_report(svn_bo
   rb.from_rev = from_rev;
   if (from_rev)
     *from_rev = SVN_INVALID_REVNUM;
-  err = svn_ra_svn_handle_commands2(conn, pool, report_commands, &rb, TRUE);
+  err = svn_ra_svn__handle_commands2(conn, pool, report_commands, &rb, TRUE);
   if (err)
     {
       /* Network or protocol error while handling commands. */
@@ -986,7 +996,7 @@ static svn_error_t *accept_report(svn_bo
       /* Some failure during the reporting or editing operations. */
       SVN_CMD_ERR(rb.err);
     }
-  SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, ""));
+  SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, ""));
 
   if (only_empty_entry)
     *only_empty_entry = rb.entry_counter == 1 && rb.only_empty_entries;
@@ -1008,8 +1018,8 @@ static svn_error_t *write_prop_diffs(svn
     {
       const svn_prop_t *prop = &APR_ARRAY_IDX(propdiffs, i, svn_prop_t);
 
-      SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "c(?s)",
-                                     prop->name, prop->value));
+      SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "c(?s)",
+                                      prop->name, prop->value));
     }
 
   return SVN_NO_ERROR;
@@ -1025,9 +1035,9 @@ static svn_error_t *write_lock(svn_ra_sv
   cdate = svn_time_to_cstring(lock->creation_date, pool);
   edate = lock->expiration_date
     ? svn_time_to_cstring(lock->expiration_date, pool) : NULL;
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "ccc(?c)c(?c)", lock->path,
-                                 lock->token, lock->owner, lock->comment,
-                                 cdate, edate));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "ccc(?c)c(?c)", lock->path,
+                                  lock->token, lock->owner, lock->comment,
+                                  cdate, edate));
 
   return SVN_NO_ERROR;
 }
@@ -1089,7 +1099,7 @@ static svn_error_t *reparent(svn_ra_svn_
   const char *url;
   const char *fs_path;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "c", &url));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "c", &url));
   url = svn_uri_canonicalize(url, pool);
   SVN_ERR(trivial_auth_request(conn, pool, b));
   SVN_CMD_ERR(get_fs_path(svn_path_uri_decode(b->repos_url, pool),
@@ -1097,7 +1107,7 @@ static svn_error_t *reparent(svn_ra_svn_
                           &fs_path));
   SVN_ERR(log_command(b, conn, pool, "%s", svn_log__reparent(fs_path, pool)));
   svn_stringbuf_set(b->fs_path, fs_path);
-  SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, ""));
+  SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, ""));
   return SVN_NO_ERROR;
 }
 
@@ -1111,7 +1121,7 @@ static svn_error_t *get_latest_rev(svn_r
 
   SVN_ERR(trivial_auth_request(conn, pool, b));
   SVN_CMD_ERR(svn_fs_youngest_rev(&rev, b->fs, pool));
-  SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, "r", rev));
+  SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, "r", rev));
   return SVN_NO_ERROR;
 }
 
@@ -1123,13 +1133,13 @@ static svn_error_t *get_dated_rev(svn_ra
   apr_time_t tm;
   const char *timestr;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "c", &timestr));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "c", &timestr));
   SVN_ERR(log_command(b, conn, pool, "get-dated-rev %s", timestr));
 
   SVN_ERR(trivial_auth_request(conn, pool, b));
   SVN_CMD_ERR(svn_time_from_cstring(&tm, timestr, pool));
   SVN_CMD_ERR(svn_repos_dated_revision(&rev, b->repos, tm, pool));
-  SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, "r", rev));
+  SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, "r", rev));
   return SVN_NO_ERROR;
 }
 
@@ -1155,7 +1165,7 @@ static svn_error_t *do_change_rev_prop(s
                                             TRUE, TRUE,
                                             authz_check_access_cb_func(b), &ab,
                                             pool));
-  SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, ""));
+  SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, ""));
 
   return SVN_NO_ERROR;
 }
@@ -1171,9 +1181,9 @@ static svn_error_t *change_rev_prop2(svn
   svn_string_t *old_value;
   svn_boolean_t dont_care;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "rc(?s)(b?s)",
-                                 &rev, &name, &value,
-                                 &dont_care, &old_value));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "rc(?s)(b?s)",
+                                  &rev, &name, &value,
+                                  &dont_care, &old_value));
 
   /* Argument parsing. */
   if (dont_care)
@@ -1207,7 +1217,7 @@ static svn_error_t *change_rev_prop(svn_
 
   /* Because the revprop value was at one time mandatory, the usual
      optional element pattern "(?s)" isn't used. */
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "rc?s", &rev, &name, &value));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "rc?s", &rev, &name, &value));
 
   SVN_ERR(do_change_rev_prop(conn, b, rev, name, NULL, value, pool));
 
@@ -1225,16 +1235,16 @@ static svn_error_t *rev_proplist(svn_ra_
   ab.server = b;
   ab.conn = conn;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "r", &rev));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "r", &rev));
   SVN_ERR(log_command(b, conn, pool, "%s", svn_log__rev_proplist(rev, pool)));
 
   SVN_ERR(trivial_auth_request(conn, pool, b));
   SVN_CMD_ERR(svn_repos_fs_revision_proplist(&props, b->repos, rev,
                                              authz_check_access_cb_func(b), &ab,
                                              pool));
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "w((!", "success"));
-  SVN_ERR(svn_ra_svn_write_proplist(conn, pool, props));
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!))"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "w((!", "success"));
+  SVN_ERR(svn_ra_svn__write_proplist(conn, pool, props));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!))"));
   return SVN_NO_ERROR;
 }
 
@@ -1250,7 +1260,7 @@ static svn_error_t *rev_prop(svn_ra_svn_
   ab.server = b;
   ab.conn = conn;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "rc", &rev, &name));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "rc", &rev, &name));
   SVN_ERR(log_command(b, conn, pool, "%s",
                       svn_log__rev_prop(rev, name, pool)));
 
@@ -1258,7 +1268,7 @@ static svn_error_t *rev_prop(svn_ra_svn_
   SVN_CMD_ERR(svn_repos_fs_revision_prop(&value, b->repos, rev, name,
                                          authz_check_access_cb_func(b), &ab,
                                          pool));
-  SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, "(?s)", value));
+  SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, "(?s)", value));
   return SVN_NO_ERROR;
 }
 
@@ -1404,7 +1414,7 @@ static svn_error_t *commit(svn_ra_svn_co
     {
       /* Clients before 1.2 don't send lock-tokens, keep-locks,
          and rev-props fields. */
-      SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "c", &log_msg));
+      SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "c", &log_msg));
       lock_tokens = NULL;
       keep_locks = TRUE;
       revprop_list = NULL;
@@ -1412,9 +1422,9 @@ static svn_error_t *commit(svn_ra_svn_co
   else
     {
       /* Clients before 1.5 don't send the rev-props field. */
-      SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "clb?l", &log_msg,
-                                     &lock_tokens, &keep_locks,
-                                     &revprop_list));
+      SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "clb?l", &log_msg,
+                                      &lock_tokens, &keep_locks,
+                                      &revprop_list));
     }
 
   /* The handling for locks is a little problematic, because the
@@ -1432,7 +1442,7 @@ static svn_error_t *commit(svn_ra_svn_co
     SVN_CMD_ERR(add_lock_tokens(conn, lock_tokens, b, pool));
 
   if (revprop_list)
-    SVN_ERR(svn_ra_svn_parse_proplist(revprop_list, pool, &revprop_table));
+    SVN_ERR(svn_ra_svn__parse_proplist(revprop_list, pool, &revprop_table));
   else
     {
       revprop_table = apr_hash_make(pool);
@@ -1457,8 +1467,9 @@ static svn_error_t *commit(svn_ra_svn_co
                b->fs_path->data, revprop_table,
                commit_done, &ccb,
                authz_commit_cb, &ab, pool));
-  SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, ""));
-  SVN_ERR(svn_ra_svn_drive_editor(conn, pool, editor, edit_baton, &aborted));
+  SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, ""));
+  SVN_ERR(svn_ra_svn_drive_editor2(conn, pool, editor, edit_baton,
+                                   &aborted, FALSE));
   if (!aborted)
     {
       SVN_ERR(log_command(b, conn, pool, "%s",
@@ -1477,8 +1488,8 @@ static svn_error_t *commit(svn_ra_svn_co
       if (! keep_locks && lock_tokens && lock_tokens->nelts)
         SVN_ERR(unlock_paths(lock_tokens, b, conn, pool));
 
-      SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "r(?c)(?c)(?c)",
-                                     new_rev, date, author, post_commit_err));
+      SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "r(?c)(?c)(?c)",
+                                      new_rev, date, author, post_commit_err));
 
       if (! b->tunnel)
         SVN_ERR(svn_fs_deltify_revision(b->fs, new_rev, pool));
@@ -1510,9 +1521,9 @@ static svn_error_t *get_file(svn_ra_svn_
   ab.conn = conn;
 
   /* Parse arguments. */
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "c(?r)bb?B", &path, &rev,
-                                 &want_props, &want_contents,
-                                 &wants_inherited_props));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "c(?r)bb?B", &path, &rev,
+                                  &want_props, &want_contents,
+                                  &wants_inherited_props));
 
   full_path = svn_fspath__join(b->fs_path->data,
                                svn_relpath_canonicalize(path, pool), pool);
@@ -1540,31 +1551,31 @@ static svn_error_t *get_file(svn_ra_svn_
     SVN_CMD_ERR(svn_fs_file_contents(&contents, root, full_path, pool));
 
   /* Send successful command response with revision and props. */
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "w((?c)r(!", "success",
-                                 hex_digest, rev));
-  SVN_ERR(svn_ra_svn_write_proplist(conn, pool, props));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "w((?c)r(!", "success",
+                                  hex_digest, rev));
+  SVN_ERR(svn_ra_svn__write_proplist(conn, pool, props));
 
   if (wants_inherited_props)
     {
       apr_pool_t *iterpool = svn_pool_create(pool);
 
-      SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!)(?!"));
+      SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!)(?!"));
       for (i = 0; i < inherited_props->nelts; i++)
         {
           svn_prop_inherited_item_t *iprop =
             APR_ARRAY_IDX(inherited_props, i, svn_prop_inherited_item_t *);
 
           svn_pool_clear(iterpool);
-          SVN_ERR(svn_ra_svn_write_tuple(conn, iterpool, "!(c(!",
-                                         iprop->path_or_url));
-          SVN_ERR(svn_ra_svn_write_proplist(conn, iterpool, iprop->prop_hash));
-          SVN_ERR(svn_ra_svn_write_tuple(conn, iterpool, "!))!",
-                                         iprop->path_or_url));
+          SVN_ERR(svn_ra_svn__write_tuple(conn, iterpool, "!(c(!",
+                                          iprop->path_or_url));
+          SVN_ERR(svn_ra_svn__write_proplist(conn, iterpool, iprop->prop_hash));
+          SVN_ERR(svn_ra_svn__write_tuple(conn, iterpool, "!))!",
+                                          iprop->path_or_url));
         }
       svn_pool_destroy(iterpool);
     }
 
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!))"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!))"));
 
   /* Now send the file's contents. */
   if (want_contents)
@@ -1580,7 +1591,7 @@ static svn_error_t *get_file(svn_ra_svn_
             {
               write_str.data = buf;
               write_str.len = len;
-              SVN_ERR(svn_ra_svn_write_string(conn, pool, &write_str));
+              SVN_ERR(svn_ra_svn__write_string(conn, pool, &write_str));
             }
           if (len < sizeof(buf))
             {
@@ -1588,14 +1599,14 @@ static svn_error_t *get_file(svn_ra_svn_
               break;
             }
         }
-      write_err = svn_ra_svn_write_cstring(conn, pool, "");
+      write_err = svn_ra_svn__write_cstring(conn, pool, "");
       if (write_err)
         {
           svn_error_clear(err);
           return write_err;
         }
       SVN_CMD_ERR(err);
-      SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, ""));
+      SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, ""));
     }
 
   return SVN_NO_ERROR;
@@ -1623,10 +1634,10 @@ static svn_error_t *get_dir(svn_ra_svn_c
   ab.server = b;
   ab.conn = conn;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "c(?r)bb?l?B", &path, &rev,
-                                 &want_props, &want_contents,
-                                 &dirent_fields_list,
-                                 &wants_inherited_props));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "c(?r)bb?l?B", &path, &rev,
+                                  &want_props, &want_contents,
+                                  &dirent_fields_list,
+                                  &wants_inherited_props));
 
   if (! dirent_fields_list)
     {
@@ -1684,9 +1695,9 @@ static svn_error_t *get_dir(svn_ra_svn_c
                           pool));
 
   /* Begin response ... */
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "w(r(!", "success", rev));
-  SVN_ERR(svn_ra_svn_write_proplist(conn, pool, props));
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!)(!"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "w(r(!", "success", rev));
+  SVN_ERR(svn_ra_svn__write_proplist(conn, pool, props));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!)(!"));
 
   /* Fetch the directory entries if requested and send them immediately. */
   if (want_contents)
@@ -1764,11 +1775,11 @@ static svn_error_t *get_dir(svn_ra_svn_c
             cdate = missing_date;
 
           /* Send the entry. */
-          SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "cwnbr(?c)(?c)", name,
-                                         svn_node_kind_to_word(entry_kind),
-                                         (apr_uint64_t) entry_size,
-                                         has_props, created_rev,
-                                         cdate, last_author));
+          SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "cwnbr(?c)(?c)", name,
+                                          svn_node_kind_to_word(entry_kind),
+                                          (apr_uint64_t) entry_size,
+                                          has_props, created_rev,
+                                          cdate, last_author));
         }
       svn_pool_destroy(subpool);
     }
@@ -1777,24 +1788,24 @@ static svn_error_t *get_dir(svn_ra_svn_c
     {
       apr_pool_t *iterpool = svn_pool_create(pool);
 
-      SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!)(?!"));
+      SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!)(?!"));
       for (i = 0; i < inherited_props->nelts; i++)
         {
           svn_prop_inherited_item_t *iprop =
             APR_ARRAY_IDX(inherited_props, i, svn_prop_inherited_item_t *);
 
           svn_pool_clear(iterpool);
-          SVN_ERR(svn_ra_svn_write_tuple(conn, iterpool, "!(c(!",
-                                         iprop->path_or_url));
-          SVN_ERR(svn_ra_svn_write_proplist(conn, iterpool, iprop->prop_hash));
-          SVN_ERR(svn_ra_svn_write_tuple(conn, iterpool, "!))!",
-                                         iprop->path_or_url));
+          SVN_ERR(svn_ra_svn__write_tuple(conn, iterpool, "!(c(!",
+                                          iprop->path_or_url));
+          SVN_ERR(svn_ra_svn__write_proplist(conn, iterpool, iprop->prop_hash));
+          SVN_ERR(svn_ra_svn__write_tuple(conn, iterpool, "!))!",
+                                          iprop->path_or_url));
         }
       svn_pool_destroy(iterpool);
     }
 
   /* Finish response. */
-  return svn_ra_svn_write_tuple(conn, pool, "!))");
+  return svn_ra_svn__write_tuple(conn, pool, "!))");
 }
 
 static svn_error_t *update(svn_ra_svn_conn_t *conn, apr_pool_t *pool,
@@ -1804,16 +1815,17 @@ static svn_error_t *update(svn_ra_svn_co
   svn_revnum_t rev;
   const char *target, *full_path, *depth_word;
   svn_boolean_t recurse;
-  svn_boolean_t send_copyfrom_args;
-  apr_uint64_t send_copyfrom_param;
+  svn_tristate_t send_copyfrom_args; /* Optional; default FALSE */
+  svn_tristate_t ignore_ancestry; /* Optional; default FALSE */
   /* Default to unknown.  Old clients won't send depth, but we'll
      handle that by converting recurse if necessary. */
   svn_depth_t depth = svn_depth_unknown;
   svn_boolean_t is_checkout;
 
   /* Parse the arguments. */
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "(?r)cb?wB", &rev, &target,
-                                 &recurse, &depth_word, &send_copyfrom_param));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "(?r)cb?w3?3", &rev, &target,
+                                  &recurse, &depth_word,
+                                  &send_copyfrom_args, &ignore_ancestry));
   target = svn_relpath_canonicalize(target, pool);
 
   if (depth_word)
@@ -1821,9 +1833,6 @@ static svn_error_t *update(svn_ra_svn_co
   else
     depth = SVN_DEPTH_INFINITY_OR_FILES(recurse);
 
-  send_copyfrom_args = (send_copyfrom_param == SVN_RA_SVN_UNSPECIFIED_NUMBER) ?
-      FALSE : (svn_boolean_t) send_copyfrom_param;
-
   full_path = svn_fspath__join(b->fs_path->data, target, pool);
   /* Check authorization and authenticate the user if necessary. */
   SVN_ERR(must_have_access(conn, pool, b, svn_authz_read, full_path, FALSE));
@@ -1833,7 +1842,9 @@ static svn_error_t *update(svn_ra_svn_co
 
   SVN_ERR(accept_report(&is_checkout, NULL,
                         conn, pool, b, rev, target, NULL, TRUE,
-                        depth, send_copyfrom_args, FALSE));
+                        depth,
+                        (send_copyfrom_args == svn_tristate_true),
+                        (ignore_ancestry == svn_tristate_true)));
   if (is_checkout)
     {
       SVN_ERR(log_command(b, conn, pool, "%s",
@@ -1844,7 +1855,9 @@ static svn_error_t *update(svn_ra_svn_co
     {
       SVN_ERR(log_command(b, conn, pool, "%s",
                           svn_log__update(full_path, rev, depth,
-                                          send_copyfrom_args, pool)));
+                                          (send_copyfrom_args
+                                           == svn_tristate_true),
+                                          pool)));
     }
 
   return SVN_NO_ERROR;
@@ -1861,13 +1874,13 @@ static svn_error_t *switch_cmd(svn_ra_sv
   /* Default to unknown.  Old clients won't send depth, but we'll
      handle that by converting recurse if necessary. */
   svn_depth_t depth = svn_depth_unknown;
-  apr_uint64_t send_copyfrom_args; /* Optional; default FALSE */
-  apr_uint64_t ignore_ancestry; /* Optional; default TRUE */
+  svn_tristate_t send_copyfrom_args; /* Optional; default FALSE */
+  svn_tristate_t ignore_ancestry; /* Optional; default TRUE */
 
   /* Parse the arguments. */
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "(?r)cbc?w?BB", &rev, &target,
-                                 &recurse, &switch_url, &depth_word,
-                                 &send_copyfrom_args, &ignore_ancestry));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "(?r)cbc?w?33", &rev, &target,
+                                  &recurse, &switch_url, &depth_word,
+                                  &send_copyfrom_args, &ignore_ancestry));
   target = svn_relpath_canonicalize(target, pool);
   switch_url = svn_uri_canonicalize(switch_url, pool);
 
@@ -1894,8 +1907,8 @@ static svn_error_t *switch_cmd(svn_ra_sv
   return accept_report(NULL, NULL,
                        conn, pool, b, rev, target, switch_path, TRUE,
                        depth,
-                       (send_copyfrom_args == TRUE) /* send_copyfrom_args */,
-                       (ignore_ancestry != FALSE) /* ignore_ancestry */);
+                       (send_copyfrom_args == svn_tristate_true),
+                       (ignore_ancestry != svn_tristate_false));
 }
 
 static svn_error_t *status(svn_ra_svn_conn_t *conn, apr_pool_t *pool,
@@ -1910,8 +1923,8 @@ static svn_error_t *status(svn_ra_svn_co
   svn_depth_t depth = svn_depth_unknown;
 
   /* Parse the arguments. */
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "cb?(?r)?w",
-                                 &target, &recurse, &rev, &depth_word));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "cb?(?r)?w",
+                                  &target, &recurse, &rev, &depth_word));
   target = svn_relpath_canonicalize(target, pool);
 
   if (depth_word)
@@ -1949,17 +1962,17 @@ static svn_error_t *diff(svn_ra_svn_conn
   if (params->nelts == 5)
     {
       /* Clients before 1.4 don't send the text_deltas boolean or depth. */
-      SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "(?r)cbbc", &rev, &target,
-                                     &recurse, &ignore_ancestry, &versus_url));
+      SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "(?r)cbbc", &rev, &target,
+                                      &recurse, &ignore_ancestry, &versus_url));
       text_deltas = TRUE;
       depth_word = NULL;
     }
   else
     {
-      SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "(?r)cbbcb?w",
-                                     &rev, &target, &recurse,
-                                     &ignore_ancestry, &versus_url,
-                                     &text_deltas, &depth_word));
+      SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "(?r)cbbcb?w",
+                                      &rev, &target, &recurse,
+                                      &ignore_ancestry, &versus_url,
+                                      &text_deltas, &depth_word));
     }
   target = svn_relpath_canonicalize(target, pool);
   versus_url = svn_uri_canonicalize(versus_url, pool);
@@ -2015,8 +2028,8 @@ static svn_error_t *get_mergeinfo(svn_ra
   ab.server = b;
   ab.conn = conn;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "l(?r)wb", &paths, &rev,
-                                 &inherit_word, &include_descendants));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "l(?r)wb", &paths, &rev,
+                                  &inherit_word, &include_descendants));
   inherit = svn_inheritance_from_word(inherit_word);
 
   /* Canonicalize the paths which mergeinfo has been requested for. */
@@ -2048,7 +2061,7 @@ static svn_error_t *get_mergeinfo(svn_ra
                                          pool));
   SVN_ERR(svn_mergeinfo__remove_prefix_from_catalog(&mergeinfo, mergeinfo,
                                                     b->fs_path->data, pool));
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "w((!", "success"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "w((!", "success"));
   iterpool = svn_pool_create(pool);
   for (hi = apr_hash_first(pool, mergeinfo); hi; hi = apr_hash_next(hi))
     {
@@ -2059,11 +2072,11 @@ static svn_error_t *get_mergeinfo(svn_ra
       svn_pool_clear(iterpool);
 
       SVN_ERR(svn_mergeinfo_to_string(&mergeinfo_string, value, iterpool));
-      SVN_ERR(svn_ra_svn_write_tuple(conn, iterpool, "cs", key,
-                                     mergeinfo_string));
+      SVN_ERR(svn_ra_svn__write_tuple(conn, iterpool, "cs", key,
+                                      mergeinfo_string));
     }
   svn_pool_destroy(iterpool);
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!))"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!))"));
 
   return SVN_NO_ERROR;
 }
@@ -2095,7 +2108,7 @@ static svn_error_t *log_receiver(void *b
       b->stack_depth--;
     }
 
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "(!"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "(!"));
   if (log_entry->changed_paths2)
     {
       for (h = apr_hash_first(pool, log_entry->changed_paths2); h;
@@ -2106,7 +2119,7 @@ static svn_error_t *log_receiver(void *b
 
           action[0] = change->action;
           action[1] = '\0';
-          SVN_ERR(svn_ra_svn_write_tuple(
+          SVN_ERR(svn_ra_svn__write_tuple(
                       conn, pool, "cw(?cr)(cbb)",
                       path,
                       action,
@@ -2124,14 +2137,14 @@ static svn_error_t *log_receiver(void *b
     revprop_count = apr_hash_count(log_entry->revprops);
   else
     revprop_count = 0;
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!)r(?c)(?c)(?c)bbn(!",
-                                 log_entry->revision,
-                                 author, date, message,
-                                 log_entry->has_children,
-                                 invalid_revnum, revprop_count));
-  SVN_ERR(svn_ra_svn_write_proplist(conn, pool, log_entry->revprops));
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!)b",
-                                 log_entry->subtractive_merge));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!)r(?c)(?c)(?c)bbn(!",
+                                  log_entry->revision,
+                                  author, date, message,
+                                  log_entry->has_children,
+                                  invalid_revnum, revprop_count));
+  SVN_ERR(svn_ra_svn__write_proplist(conn, pool, log_entry->revprops));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!)b",
+                                  log_entry->subtractive_merge));
 
   if (log_entry->has_children)
     b->stack_depth++;
@@ -2158,11 +2171,11 @@ static svn_error_t *log_cmd(svn_ra_svn_c
   ab.server = b;
   ab.conn = conn;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "l(?r)(?r)bb?n?Bwl", &paths,
-                                 &start_rev, &end_rev, &send_changed_paths,
-                                 &strict_node, &limit,
-                                 &include_merged_revs_param,
-                                 &revprop_word, &revprop_items));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "l(?r)(?r)bb?n?Bwl", &paths,
+                                  &start_rev, &end_rev, &send_changed_paths,
+                                  &strict_node, &limit,
+                                  &include_merged_revs_param,
+                                  &revprop_word, &revprop_items));
 
   if (include_merged_revs_param == SVN_RA_SVN_UNSPECIFIED_NUMBER)
     include_merged_revisions = FALSE;
@@ -2230,14 +2243,14 @@ static svn_error_t *log_cmd(svn_ra_svn_c
                             authz_check_access_cb_func(b), &ab, log_receiver,
                             &lb, pool);
 
-  write_err = svn_ra_svn_write_word(conn, pool, "done");
+  write_err = svn_ra_svn__write_word(conn, pool, "done");
   if (write_err)
     {
       svn_error_clear(err);
       return write_err;
     }
   SVN_CMD_ERR(err);
-  SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, ""));
+  SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, ""));
   return SVN_NO_ERROR;
 }
 
@@ -2250,7 +2263,7 @@ static svn_error_t *check_path(svn_ra_sv
   svn_fs_root_t *root;
   svn_node_kind_t kind;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "c(?r)", &path, &rev));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "c(?r)", &path, &rev));
   full_path = svn_fspath__join(b->fs_path->data,
                                svn_relpath_canonicalize(path, pool), pool);
 
@@ -2266,8 +2279,8 @@ static svn_error_t *check_path(svn_ra_sv
 
   SVN_CMD_ERR(svn_fs_revision_root(&root, b->fs, rev, pool));
   SVN_CMD_ERR(svn_fs_check_path(&kind, root, full_path, pool));
-  SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, "w",
-                                        svn_node_kind_to_word(kind)));
+  SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, "w",
+                                         svn_node_kind_to_word(kind)));
   return SVN_NO_ERROR;
 }
 
@@ -2280,7 +2293,7 @@ static svn_error_t *stat_cmd(svn_ra_svn_
   svn_fs_root_t *root;
   svn_dirent_t *dirent;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "c(?r)", &path, &rev));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "c(?r)", &path, &rev));
   full_path = svn_fspath__join(b->fs_path->data,
                                svn_relpath_canonicalize(path, pool), pool);
 
@@ -2302,18 +2315,18 @@ static svn_error_t *stat_cmd(svn_ra_svn_
 
   if (dirent == NULL)
     {
-      SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, "()"));
+      SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, "()"));
       return SVN_NO_ERROR;
     }
 
   cdate = (dirent->time == (time_t) -1) ? NULL
     : svn_time_to_cstring(dirent->time, pool);
 
-  SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, "((wnbr(?c)(?c)))",
-                                        svn_node_kind_to_word(dirent->kind),
-                                        (apr_uint64_t) dirent->size,
-                                        dirent->has_props, dirent->created_rev,
-                                        cdate, dirent->last_author));
+  SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, "((wnbr(?c)(?c)))",
+                                         svn_node_kind_to_word(dirent->kind),
+                                         (apr_uint64_t) dirent->size,
+                                         dirent->has_props, dirent->created_rev,
+                                         cdate, dirent->last_author));
 
   return SVN_NO_ERROR;
 }
@@ -2337,9 +2350,9 @@ static svn_error_t *get_locations(svn_ra
   ab.conn = conn;
 
   /* Parse the arguments. */
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "crl", &relative_path,
-                                 &peg_revision,
-                                 &loc_revs_proto));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "crl", &relative_path,
+                                  &peg_revision,
+                                  &loc_revs_proto));
   relative_path = svn_relpath_canonicalize(relative_path, pool);
 
   abs_path = svn_fspath__join(b->fs_path->data, relative_path, pool);
@@ -2385,13 +2398,13 @@ static svn_error_t *get_locations(svn_ra
               const svn_revnum_t *iter_key = svn__apr_hash_index_key(iter);
               const char *iter_value = svn__apr_hash_index_val(iter);
 
-              SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "rc",
-                                             *iter_key, iter_value));
+              SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "rc",
+                                              *iter_key, iter_value));
             }
         }
     }
 
-  write_err = svn_ra_svn_write_word(conn, pool, "done");
+  write_err = svn_ra_svn__write_word(conn, pool, "done");
   if (write_err)
     {
       svn_error_clear(err);
@@ -2399,7 +2412,7 @@ static svn_error_t *get_locations(svn_ra
     }
   SVN_CMD_ERR(err);
 
-  SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, ""));
+  SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, ""));
 
   return SVN_NO_ERROR;
 }
@@ -2409,10 +2422,10 @@ static svn_error_t *gls_receiver(svn_loc
                                  apr_pool_t *pool)
 {
   svn_ra_svn_conn_t *conn = baton;
-  return svn_ra_svn_write_tuple(conn, pool, "rr(?c)",
-                                segment->range_start,
-                                segment->range_end,
-                                segment->path);
+  return svn_ra_svn__write_tuple(conn, pool, "rr(?c)",
+                                 segment->range_start,
+                                 segment->range_end,
+                                 segment->path);
 }
 
 static svn_error_t *get_location_segments(svn_ra_svn_conn_t *conn,
@@ -2431,9 +2444,9 @@ static svn_error_t *get_location_segment
   ab.conn = conn;
 
   /* Parse the arguments. */
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "c(?r)(?r)(?r)",
-                                 &relative_path, &peg_revision,
-                                 &start_rev, &end_rev));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "c(?r)(?r)(?r)",
+                                  &relative_path, &peg_revision,
+                                  &start_rev, &end_rev));
   relative_path = svn_relpath_canonicalize(relative_path, pool);
 
   abs_path = svn_fspath__join(b->fs_path->data, relative_path, pool);
@@ -2475,7 +2488,7 @@ static svn_error_t *get_location_segment
                                          gls_receiver, (void *)conn,
                                          authz_check_access_cb_func(b), &ab,
                                          pool);
-  write_err = svn_ra_svn_write_word(conn, pool, "done");
+  write_err = svn_ra_svn__write_word(conn, pool, "done");
   if (write_err)
     {
       svn_error_clear(err);
@@ -2483,7 +2496,7 @@ static svn_error_t *get_location_segment
     }
   SVN_CMD_ERR(err);
 
-  SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, ""));
+  SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, ""));
 
   return SVN_NO_ERROR;
 }
@@ -2498,7 +2511,7 @@ static svn_error_t *svndiff_handler(void
 
   str.data = data;
   str.len = *len;
-  return svn_ra_svn_write_string(b->conn, b->pool, &str);
+  return svn_ra_svn__write_string(b->conn, b->pool, &str);
 }
 
 /* This implements svn_close_fn_t.  Mark the end of the data by writing an
@@ -2507,7 +2520,7 @@ static svn_error_t *svndiff_close_handle
 {
   file_revs_baton_t *b = baton;
 
-  SVN_ERR(svn_ra_svn_write_cstring(b->conn, b->pool, ""));
+  SVN_ERR(svn_ra_svn__write_cstring(b->conn, b->pool, ""));
   return SVN_NO_ERROR;
 }
 
@@ -2523,12 +2536,12 @@ static svn_error_t *file_rev_handler(voi
   file_revs_baton_t *frb = baton;
   svn_stream_t *stream;
 
-  SVN_ERR(svn_ra_svn_write_tuple(frb->conn, pool, "cr(!",
-                                 path, rev));
-  SVN_ERR(svn_ra_svn_write_proplist(frb->conn, pool, rev_props));
-  SVN_ERR(svn_ra_svn_write_tuple(frb->conn, pool, "!)(!"));
+  SVN_ERR(svn_ra_svn__write_tuple(frb->conn, pool, "cr(!",
+                                  path, rev));
+  SVN_ERR(svn_ra_svn__write_proplist(frb->conn, pool, rev_props));
+  SVN_ERR(svn_ra_svn__write_tuple(frb->conn, pool, "!)(!"));
   SVN_ERR(write_prop_diffs(frb->conn, pool, prop_diffs));
-  SVN_ERR(svn_ra_svn_write_tuple(frb->conn, pool, "!)b", merged_revision));
+  SVN_ERR(svn_ra_svn__write_tuple(frb->conn, pool, "!)b", merged_revision));
 
   /* Store the pool for the delta stream. */
   frb->pool = pool;
@@ -2551,7 +2564,7 @@ static svn_error_t *file_rev_handler(voi
                                 svn_ra_svn_compression_level(frb->conn), pool);
     }
   else
-    SVN_ERR(svn_ra_svn_write_cstring(frb->conn, pool, ""));
+    SVN_ERR(svn_ra_svn__write_cstring(frb->conn, pool, ""));
 
   return SVN_NO_ERROR;
 }
@@ -2573,9 +2586,9 @@ static svn_error_t *get_file_revs(svn_ra
   ab.conn = conn;
 
   /* Parse arguments. */
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "c(?r)(?r)?B",
-                                 &path, &start_rev, &end_rev,
-                                 &include_merged_revs_param));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "c(?r)(?r)?B",
+                                  &path, &start_rev, &end_rev,
+                                  &include_merged_revs_param));
   path = svn_relpath_canonicalize(path, pool);
   SVN_ERR(trivial_auth_request(conn, pool, b));
   full_path = svn_fspath__join(b->fs_path->data, path, pool);
@@ -2597,14 +2610,14 @@ static svn_error_t *get_file_revs(svn_ra
                                  include_merged_revisions,
                                  authz_check_access_cb_func(b), &ab,
                                  file_rev_handler, &frb, pool);
-  write_err = svn_ra_svn_write_word(conn, pool, "done");
+  write_err = svn_ra_svn__write_word(conn, pool, "done");
   if (write_err)
     {
       svn_error_clear(err);
       return write_err;
     }
   SVN_CMD_ERR(err);
-  SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, ""));
+  SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, ""));
 
   return SVN_NO_ERROR;
 }
@@ -2620,8 +2633,8 @@ static svn_error_t *lock(svn_ra_svn_conn
   svn_revnum_t current_rev;
   svn_lock_t *l;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "c(?c)b(?r)", &path, &comment,
-                                 &steal_lock, &current_rev));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "c(?c)b(?r)", &path, &comment,
+                                  &steal_lock, &current_rev));
   full_path = svn_fspath__join(b->fs_path->data,
                                svn_relpath_canonicalize(path, pool), pool);
 
@@ -2634,9 +2647,9 @@ static svn_error_t *lock(svn_ra_svn_conn
                                 0, /* No expiration time. */
                                 current_rev, steal_lock, pool));
 
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "w(!", "success"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "w(!", "success"));
   SVN_ERR(write_lock(conn, pool, l));
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!)"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!)"));
 
   return SVN_NO_ERROR;
 }
@@ -2657,8 +2670,8 @@ static svn_error_t *lock_many(svn_ra_svn
   svn_lock_t *l;
   svn_error_t *err = SVN_NO_ERROR, *write_err;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "(?c)bl", &comment, &steal_lock,
-                                 &path_revs));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "(?c)bl", &comment, &steal_lock,
+                                  &path_revs));
 
   subpool = svn_pool_create(pool);
 
@@ -2681,8 +2694,8 @@ static svn_error_t *lock_many(svn_ra_svn
         return svn_error_create(SVN_ERR_RA_SVN_MALFORMED_DATA, NULL,
                                 "Lock requests should be list of lists");
 
-      SVN_ERR(svn_ra_svn_parse_tuple(item->u.list, pool, "c(?r)", &path,
-                                     &current_rev));
+      SVN_ERR(svn_ra_svn__parse_tuple(item->u.list, pool, "c(?r)", &path,
+                                      &current_rev));
 
       /* Allocate the full_path out of pool so it will survive for use
        * by operational logging, after this loop. */
@@ -2708,7 +2721,7 @@ static svn_error_t *lock_many(svn_ra_svn
         {
           if (SVN_ERR_IS_LOCK_ERROR(err))
             {
-              write_err = svn_ra_svn_write_cmd_failure(conn, pool, err);
+              write_err = svn_ra_svn__write_cmd_failure(conn, pool, err);
               svn_error_clear(err);
               err = NULL;
               SVN_ERR(write_err);
@@ -2718,9 +2731,9 @@ static svn_error_t *lock_many(svn_ra_svn
         }
       else
         {
-          SVN_ERR(svn_ra_svn_write_tuple(conn, subpool, "w!", "success"));
+          SVN_ERR(svn_ra_svn__write_tuple(conn, subpool, "w!", "success"));
           SVN_ERR(write_lock(conn, subpool, l));
-          SVN_ERR(svn_ra_svn_write_tuple(conn, subpool, "!"));
+          SVN_ERR(svn_ra_svn__write_tuple(conn, subpool, "!"));
         }
     }
 
@@ -2730,12 +2743,12 @@ static svn_error_t *lock_many(svn_ra_svn
                       svn_log__lock(log_paths, steal_lock, pool)));
 
   /* NOTE: err might contain a fatal locking error from the loop above. */
-  write_err = svn_ra_svn_write_word(conn, pool, "done");
+  write_err = svn_ra_svn__write_word(conn, pool, "done");
   if (!write_err)
     SVN_CMD_ERR(err);
   svn_error_clear(err);
   SVN_ERR(write_err);
-  SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, ""));
+  SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, ""));
 
   return SVN_NO_ERROR;
 }
@@ -2747,7 +2760,7 @@ static svn_error_t *unlock(svn_ra_svn_co
   const char *path, *token, *full_path;
   svn_boolean_t break_lock;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "c(?c)b", &path, &token,
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "c(?c)b", &path, &token,
                                  &break_lock));
 
   full_path = svn_fspath__join(b->fs_path->data,
@@ -2762,7 +2775,7 @@ static svn_error_t *unlock(svn_ra_svn_co
   SVN_CMD_ERR(svn_repos_fs_unlock(b->repos, full_path, token, break_lock,
                                   pool));
 
-  SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, ""));
+  SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, ""));
 
   return SVN_NO_ERROR;
 }
@@ -2781,8 +2794,8 @@ static svn_error_t *unlock_many(svn_ra_s
   const char *token;
   svn_error_t *err = SVN_NO_ERROR, *write_err;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "bl", &break_lock,
-                                 &unlock_tokens));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "bl", &break_lock,
+                                  &unlock_tokens));
 
   /* Username required unless break_lock was specified. */
   SVN_ERR(must_have_access(conn, pool, b, svn_authz_write, NULL, ! break_lock));
@@ -2802,8 +2815,8 @@ static svn_error_t *unlock_many(svn_ra_s
         return svn_error_create(SVN_ERR_RA_SVN_MALFORMED_DATA, NULL,
                                 "Unlock request should be a list of lists");
 
-      SVN_ERR(svn_ra_svn_parse_tuple(item->u.list, subpool, "c(?c)", &path,
-                                     &token));
+      SVN_ERR(svn_ra_svn__parse_tuple(item->u.list, subpool, "c(?c)", &path,
+                                      &token));
 
       /* Allocate the full_path out of pool so it will survive for use
        * by operational logging, after this loop. */
@@ -2826,7 +2839,7 @@ static svn_error_t *unlock_many(svn_ra_s
         {
           if (SVN_ERR_IS_UNLOCK_ERROR(err))
             {
-              write_err = svn_ra_svn_write_cmd_failure(conn, pool, err);
+              write_err = svn_ra_svn__write_cmd_failure(conn, pool, err);
               svn_error_clear(err);
               err = NULL;
               SVN_ERR(write_err);
@@ -2835,8 +2848,8 @@ static svn_error_t *unlock_many(svn_ra_s
             break;
         }
       else
-        SVN_ERR(svn_ra_svn_write_tuple(conn, subpool, "w(c)", "success",
-                                       path));
+        SVN_ERR(svn_ra_svn__write_tuple(conn, subpool, "w(c)", "success",
+                                        path));
     }
 
   svn_pool_destroy(subpool);
@@ -2845,11 +2858,11 @@ static svn_error_t *unlock_many(svn_ra_s
                       svn_log__unlock(log_paths, break_lock, pool)));
 
   /* NOTE: err might contain a fatal unlocking error from the loop above. */
-  write_err = svn_ra_svn_write_word(conn, pool, "done");
+  write_err = svn_ra_svn__write_word(conn, pool, "done");
   if (! write_err)
     SVN_CMD_ERR(err);
   svn_error_clear(err);
-  SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, ""));
+  SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, ""));
 
   return SVN_NO_ERROR;
 }
@@ -2862,7 +2875,7 @@ static svn_error_t *get_lock(svn_ra_svn_
   const char *full_path;
   svn_lock_t *l;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "c", &path));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "c", &path));
 
   full_path = svn_fspath__join(b->fs_path->data,
                                svn_relpath_canonicalize(path, pool), pool);
@@ -2874,10 +2887,10 @@ static svn_error_t *get_lock(svn_ra_svn_
 
   SVN_CMD_ERR(svn_fs_get_lock(&l, b->fs, full_path, pool));
 
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "w((!", "success"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "w((!", "success"));
   if (l)
     SVN_ERR(write_lock(conn, pool, l));
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!))"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!))"));
 
   return SVN_NO_ERROR;
 }
@@ -2898,7 +2911,7 @@ static svn_error_t *get_locks(svn_ra_svn
   ab.server = b;
   ab.conn = conn;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "c?(?w)", &path, &depth_word));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "c?(?w)", &path, &depth_word));
 
   depth = depth_word ? svn_depth_from_word(depth_word) : svn_depth_infinity;
   if ((depth != svn_depth_empty) &&
@@ -2922,14 +2935,14 @@ static svn_error_t *get_locks(svn_ra_svn
                                       authz_check_access_cb_func(b), &ab,
                                       pool));
 
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "w((!", "success"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "w((!", "success"));
   for (hi = apr_hash_first(pool, locks); hi; hi = apr_hash_next(hi))
     {
       svn_lock_t *l = svn__apr_hash_index_val(hi);
 
       SVN_ERR(write_lock(conn, pool, l));
     }
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!))"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!))"));
 
   return SVN_NO_ERROR;
 }
@@ -2966,8 +2979,7 @@ static svn_error_t *replay_one_revision(
     svn_error_clear(editor->abort_edit(edit_baton, pool));
   SVN_CMD_ERR(err);
 
-  return svn_ra_svn_write_templated_cmd(conn, pool,
-                                        svn_ra_svn_cmd_finish_replay);
+  return svn_ra_svn__write_cmd_finish_replay(conn, pool);
 }
 
 static svn_error_t *replay(svn_ra_svn_conn_t *conn, apr_pool_t *pool,
@@ -2977,7 +2989,7 @@ static svn_error_t *replay(svn_ra_svn_co
   svn_boolean_t send_deltas;
   server_baton_t *b = baton;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "rrb", &rev, &low_water_mark,
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "rrb", &rev, &low_water_mark,
                                  &send_deltas));
 
   SVN_ERR(trivial_auth_request(conn, pool, b));
@@ -2985,7 +2997,7 @@ static svn_error_t *replay(svn_ra_svn_co
   SVN_ERR(replay_one_revision(conn, b, rev, low_water_mark,
                               send_deltas, pool));
 
-  SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, ""));
+  SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, ""));
 
   return SVN_NO_ERROR;
 }
@@ -3002,7 +3014,7 @@ static svn_error_t *replay_range(svn_ra_
   ab.server = b;
   ab.conn = conn;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "rrrb", &start_rev,
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "rrrb", &start_rev,
                                  &end_rev, &low_water_mark,
                                  &send_deltas));
 
@@ -3019,9 +3031,9 @@ static svn_error_t *replay_range(svn_ra_
                                                  authz_check_access_cb_func(b),
                                                  &ab,
                                                  iterpool));
-      SVN_ERR(svn_ra_svn_write_tuple(conn, iterpool, "w(!", "revprops"));
-      SVN_ERR(svn_ra_svn_write_proplist(conn, iterpool, props));
-      SVN_ERR(svn_ra_svn_write_tuple(conn, iterpool, "!)"));
+      SVN_ERR(svn_ra_svn__write_tuple(conn, iterpool, "w(!", "revprops"));
+      SVN_ERR(svn_ra_svn__write_proplist(conn, iterpool, props));
+      SVN_ERR(svn_ra_svn__write_tuple(conn, iterpool, "!)"));
 
       SVN_ERR(replay_one_revision(conn, b, rev, low_water_mark,
                                   send_deltas, iterpool));
@@ -3029,7 +3041,7 @@ static svn_error_t *replay_range(svn_ra_
     }
   svn_pool_destroy(iterpool);
 
-  SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, ""));
+  SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, ""));
 
   return SVN_NO_ERROR;
 }
@@ -3046,7 +3058,7 @@ get_deleted_rev(svn_ra_svn_conn_t *conn,
   svn_revnum_t end_revision;
   svn_revnum_t revision_deleted;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "crr",
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "crr",
                                  &path, &peg_revision, &end_revision));
   full_path = svn_fspath__join(b->fs_path->data,
                                svn_relpath_canonicalize(path, pool), pool);
@@ -3054,7 +3066,7 @@ get_deleted_rev(svn_ra_svn_conn_t *conn,
   SVN_ERR(trivial_auth_request(conn, pool, b));
   SVN_ERR(svn_repos_deleted_rev(b->fs, full_path, peg_revision, end_revision,
                                 &revision_deleted, pool));
-  SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, "r", revision_deleted));
+  SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, "r", revision_deleted));
   return SVN_NO_ERROR;
 }
 
@@ -3077,7 +3089,7 @@ get_inherited_props(svn_ra_svn_conn_t *c
   ab.conn = conn;
 
   /* Parse arguments. */
-  SVN_ERR(svn_ra_svn_parse_tuple(params, iterpool, "c(?r)", &path, &rev));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, iterpool, "c(?r)", &path, &rev));
 
   full_path = svn_fspath__join(b->fs_path->data,
                                svn_relpath_canonicalize(path, iterpool),
@@ -3099,9 +3111,9 @@ get_inherited_props(svn_ra_svn_conn_t *c
   SVN_CMD_ERR(get_props(NULL, &inherited_props, &ab, root, full_path, pool));
 
   /* Send successful command response with revision and props. */
-  SVN_ERR(svn_ra_svn_write_tuple(conn, iterpool, "w(!", "success"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, iterpool, "w(!", "success"));
 
-  SVN_ERR(svn_ra_svn_write_tuple(conn, iterpool, "!(?!"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, iterpool, "!(?!"));
 
   for (i = 0; i < inherited_props->nelts; i++)
     {
@@ -3109,14 +3121,14 @@ get_inherited_props(svn_ra_svn_conn_t *c
         APR_ARRAY_IDX(inherited_props, i, svn_prop_inherited_item_t *);
 
       svn_pool_clear(iterpool);
-      SVN_ERR(svn_ra_svn_write_tuple(conn, iterpool, "!(c(!",
-                                     iprop->path_or_url));
-      SVN_ERR(svn_ra_svn_write_proplist(conn, iterpool, iprop->prop_hash));
-      SVN_ERR(svn_ra_svn_write_tuple(conn, iterpool, "!))!",
-                                     iprop->path_or_url));
-    }  
+      SVN_ERR(svn_ra_svn__write_tuple(conn, iterpool, "!(c(!",
+                                      iprop->path_or_url));
+      SVN_ERR(svn_ra_svn__write_proplist(conn, iterpool, iprop->prop_hash));
+      SVN_ERR(svn_ra_svn__write_tuple(conn, iterpool, "!))!",
+                                      iprop->path_or_url));
+    }
 
-  SVN_ERR(svn_ra_svn_write_tuple(conn, iterpool, "!))"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, iterpool, "!))"));
   svn_pool_destroy(iterpool);
   return SVN_NO_ERROR;
 }
@@ -3277,9 +3289,10 @@ static svn_error_t *find_repos(const cha
     {
       b->base = svn_repos_conf_dir(b->repos, pool);
 
-      SVN_ERR(svn_config_read2(&b->cfg, svn_repos_svnserve_conf(b->repos, pool),
+      SVN_ERR(svn_config_read3(&b->cfg, svn_repos_svnserve_conf(b->repos, pool),
                                FALSE, /* must_exist */
                                FALSE, /* section_names_case_sensitive */
+                               FALSE, /* option_names_case_sensitive */
                                pool));
       SVN_ERR(load_pwdb_config(b, conn, pool));
       SVN_ERR(load_authz_config(b, conn, repos_root, pool));
@@ -3319,7 +3332,7 @@ static svn_error_t *find_repos(const cha
                  SVN_CONFIG_OPTION_HOOKS_ENV, NULL);
   if (hooks_env)
     hooks_env = svn_dirent_internal_style(hooks_env, pool);
-  SVN_ERR(svn_repos_hooks_setenv(b->repos, hooks_env, pool, pool));
+  SVN_ERR(svn_repos_hooks_setenv(b->repos, hooks_env, pool));
 
   return SVN_NO_ERROR;
 }
@@ -3514,42 +3527,42 @@ svn_error_t *serve(svn_ra_svn_conn_t *co
   /* Send greeting.  We don't support version 1 any more, so we can
    * send an empty mechlist. */
   if (params->compression_level > 0)
-    SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, "nn()(wwwwwwwwwww)",
-                                          (apr_uint64_t) 2, (apr_uint64_t) 2,
-                                          SVN_RA_SVN_CAP_EDIT_PIPELINE,
-                                          SVN_RA_SVN_CAP_SVNDIFF1,
-                                          SVN_RA_SVN_CAP_ABSENT_ENTRIES,
-                                          SVN_RA_SVN_CAP_COMMIT_REVPROPS,
-                                          SVN_RA_SVN_CAP_DEPTH,
-                                          SVN_RA_SVN_CAP_LOG_REVPROPS,
-                                          SVN_RA_SVN_CAP_ATOMIC_REVPROPS,
-                                          SVN_RA_SVN_CAP_PARTIAL_REPLAY,
-                                          SVN_RA_SVN_CAP_INHERITED_PROPS,
-                                          SVN_RA_SVN_CAP_EPHEMERAL_TXNPROPS,
-                                          SVN_RA_SVN_CAP_GET_FILE_REVS_REVERSE
-                                          ));
-  else
-    SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, "nn()(wwwwwwwwww)",
-                                          (apr_uint64_t) 2, (apr_uint64_t) 2,
-                                          SVN_RA_SVN_CAP_EDIT_PIPELINE,
-                                          SVN_RA_SVN_CAP_ABSENT_ENTRIES,
-                                          SVN_RA_SVN_CAP_COMMIT_REVPROPS,
-                                          SVN_RA_SVN_CAP_DEPTH,
-                                          SVN_RA_SVN_CAP_LOG_REVPROPS,
-                                          SVN_RA_SVN_CAP_ATOMIC_REVPROPS,
-                                          SVN_RA_SVN_CAP_PARTIAL_REPLAY,
-                                          SVN_RA_SVN_CAP_INHERITED_PROPS,
-                                          SVN_RA_SVN_CAP_EPHEMERAL_TXNPROPS,
-                                          SVN_RA_SVN_CAP_GET_FILE_REVS_REVERSE
-                                          ));
+    SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, "nn()(wwwwwwwwwww)",
+                                           (apr_uint64_t) 2, (apr_uint64_t) 2,
+                                           SVN_RA_SVN_CAP_EDIT_PIPELINE,
+                                           SVN_RA_SVN_CAP_SVNDIFF1,
+                                           SVN_RA_SVN_CAP_ABSENT_ENTRIES,
+                                           SVN_RA_SVN_CAP_COMMIT_REVPROPS,
+                                           SVN_RA_SVN_CAP_DEPTH,
+                                           SVN_RA_SVN_CAP_LOG_REVPROPS,
+                                           SVN_RA_SVN_CAP_ATOMIC_REVPROPS,
+                                           SVN_RA_SVN_CAP_PARTIAL_REPLAY,
+                                           SVN_RA_SVN_CAP_INHERITED_PROPS,
+                                           SVN_RA_SVN_CAP_EPHEMERAL_TXNPROPS,
+                                           SVN_RA_SVN_CAP_GET_FILE_REVS_REVERSE
+                                           ));
+  else
+    SVN_ERR(svn_ra_svn__write_cmd_response(conn, pool, "nn()(wwwwwwwwww)",
+                                           (apr_uint64_t) 2, (apr_uint64_t) 2,
+                                           SVN_RA_SVN_CAP_EDIT_PIPELINE,
+                                           SVN_RA_SVN_CAP_ABSENT_ENTRIES,
+                                           SVN_RA_SVN_CAP_COMMIT_REVPROPS,
+                                           SVN_RA_SVN_CAP_DEPTH,
+                                           SVN_RA_SVN_CAP_LOG_REVPROPS,
+                                           SVN_RA_SVN_CAP_ATOMIC_REVPROPS,
+                                           SVN_RA_SVN_CAP_PARTIAL_REPLAY,
+                                           SVN_RA_SVN_CAP_INHERITED_PROPS,
+                                           SVN_RA_SVN_CAP_EPHEMERAL_TXNPROPS,
+                                           SVN_RA_SVN_CAP_GET_FILE_REVS_REVERSE
+                                           ));
 
   /* Read client response, which we assume to be in version 2 format:
    * version, capability list, and client URL; then we do an auth
    * request. */
-  SVN_ERR(svn_ra_svn_read_tuple(conn, pool, "nlc?c(?c)",
-                                &ver, &caplist, &client_url,
-                                &ra_client_string,
-                                &client_string));
+  SVN_ERR(svn_ra_svn__read_tuple(conn, pool, "nlc?c(?c)",
+                                 &ver, &caplist, &client_url,
+                                 &ra_client_string,
+                                 &client_string));
   if (ver != 2)
     return SVN_NO_ERROR;
 
@@ -3604,10 +3617,10 @@ svn_error_t *serve(svn_ra_svn_conn_t *co
     {
       log_error(err, b.log_file, svn_ra_svn_conn_remote_host(conn),
                 b.user, NULL, pool);
-      io_err = svn_ra_svn_write_cmd_failure(conn, pool, err);
+      io_err = svn_ra_svn__write_cmd_failure(conn, pool, err);
       svn_error_clear(err);
       SVN_ERR(io_err);
-      return svn_ra_svn_flush(conn, pool);
+      return svn_ra_svn__flush(conn, pool);
     }
 
   /* Log the open. */
@@ -3643,11 +3656,11 @@ svn_error_t *serve(svn_ra_svn_conn_t *co
     SVN_ERR(svn_repos_has_capability(b.repos, &supports_mergeinfo,
                                      SVN_REPOS_CAPABILITY_MERGEINFO, pool));
 
-    SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "w(cc(!",
-                                   "success", uuid, b.repos_url));
+    SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "w(cc(!",
+                                    "success", uuid, b.repos_url));
     if (supports_mergeinfo)
-      SVN_ERR(svn_ra_svn_write_word(conn, pool, SVN_RA_SVN_CAP_MERGEINFO));
-    SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!))"));
+      SVN_ERR(svn_ra_svn__write_word(conn, pool, SVN_RA_SVN_CAP_MERGEINFO));
+    SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!))"));
   }
 
   /* Set up editor shims. */
@@ -3663,5 +3676,5 @@ svn_error_t *serve(svn_ra_svn_conn_t *co
     SVN_ERR(svn_ra_svn__set_shim_callbacks(conn, callbacks));
   }
 
-  return svn_ra_svn_handle_commands2(conn, pool, main_commands, &b, FALSE);
+  return svn_ra_svn__handle_commands2(conn, pool, main_commands, &b, FALSE);
 }

Modified: subversion/branches/fsfs-format7/subversion/svnserve/server.h
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/svnserve/server.h?rev=1476675&r1=1476674&r2=1476675&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/svnserve/server.h (original)
+++ subversion/branches/fsfs-format7/subversion/svnserve/server.h Sat Apr 27 21:30:36 2013
@@ -138,7 +138,7 @@ svn_error_t *serve(svn_ra_svn_conn_t *co
                    apr_pool_t *pool);
 
 /* Load the password database for the listening server based on the
-   entries in the SERVER struct. 
+   entries in the SERVER struct.
 
    SERVER and CONN must not be NULL. The real errors will be logged with
    SERVER and CONN but return generic errors to the client. */

Modified: subversion/branches/fsfs-format7/subversion/svnserve/svnserve.c
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/svnserve/svnserve.c?rev=1476675&r1=1476674&r2=1476675&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/svnserve/svnserve.c (original)
+++ subversion/branches/fsfs-format7/subversion/svnserve/svnserve.c Sat Apr 27 21:30:36 2013
@@ -241,13 +241,11 @@ static const apr_getopt_option_t svnserv
         "                             "
         "[used for FSFS repositories only]")},
     {"client-speed", SVNSERVE_OPT_CLIENT_SPEED, 1,
-     N_("Optimize throughput based on the assumption that\n"
+     N_("Optimize network handling based on the assumption\n"
         "                             "
-        "clients can receive data with a bitrate of at\n"
+        "that most clients are connected with a bitrate of\n"
         "                             "
-        "least ARG Gbit/s.  For clients receiving data at\n"
-        "                             "
-        "less than 1 Gbit/s, zero should be used.\n"
+        "ARG Mbit/s.\n"
         "                             "
         "Default is 0 (optimizations disabled).")},
 #ifdef CONNECTION_HAVE_THREAD_OPTION
@@ -670,11 +668,16 @@ int main(int argc, const char *argv[])
           {
             apr_size_t bandwidth = (apr_size_t)apr_strtoi64(arg, NULL, 0);
 
-            /* block other clients for at most 1 ms (at full bandwidth) */
-            params.zero_copy_limit = bandwidth * 120000;
-
-            /* check for aborted connections at the same rate */
-            params.error_check_interval = bandwidth * 120000;
+            /* for slower clients, don't try anything fancy */
+            if (bandwidth >= 1000)
+              {
+                /* block other clients for at most 1 ms (at full bandwidth).
+                   Note that the send buffer is 16kB anyways. */
+                params.zero_copy_limit = bandwidth * 120;
+
+                /* check for aborted connections at the same rate */
+                params.error_check_interval = bandwidth * 120;
+              }
           }
           break;
 
@@ -752,9 +755,10 @@ int main(int argc, const char *argv[])
     {
       params.base = svn_dirent_dirname(config_filename, pool);
 
-      SVN_INT_ERR(svn_config_read2(&params.cfg, config_filename,
+      SVN_INT_ERR(svn_config_read3(&params.cfg, config_filename,
                                    TRUE, /* must_exist */
                                    FALSE, /* section_names_case_sensitive */
+                                   FALSE, /* option_names_case_sensitive */
                                    pool));
     }
 

Modified: subversion/branches/fsfs-format7/subversion/tests/cmdline/authz_tests.py
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/tests/cmdline/authz_tests.py?rev=1476675&r1=1476674&r2=1476675&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/tests/cmdline/authz_tests.py (original)
+++ subversion/branches/fsfs-format7/subversion/tests/cmdline/authz_tests.py Sat Apr 27 21:30:36 2013
@@ -1530,6 +1530,27 @@ def authz_del_from_subdir(sbox):
                                       'rm', sbox.repo_url + '/A/mu',
                                       '-m', '')
 
+
+@XFail()
+@SkipUnless(svntest.main.is_ra_type_dav) # dontdothat is dav only
+@SkipUnless(svntest.main.is_os_windows) # until the buildbots are configured
+def log_diff_dontdothat(sbox):
+  "log --diff on dontdothat"
+  sbox.build(create_wc = False)
+
+  ddt_url = sbox.repo_url.replace('/svn-test-work/', '/ddt-test-work/')
+
+  svntest.actions.run_and_verify_svn(None, None, [],
+                                      'log', sbox.repo_url,
+                                      '-c', 1, '--diff')
+
+  # We should expect a PASS or a proper error message instead of
+  # svn: E175009: XML parsing failed: (403 Forbidden)
+  svntest.actions.run_and_verify_svn(None, None, [],
+                                      'log', ddt_url,
+                                      '-c', 1, '--diff')
+
+
 ########################################################################
 # Run the tests
 
@@ -1562,6 +1583,7 @@ test_list = [ None,
               remove_subdir_with_authz_and_tc,
               authz_svnserve_groups,
               authz_del_from_subdir,
+              log_diff_dontdothat,
              ]
 serial_only = True
 

Modified: subversion/branches/fsfs-format7/subversion/tests/cmdline/autoprop_tests.py
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/tests/cmdline/autoprop_tests.py?rev=1476675&r1=1476674&r2=1476675&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/tests/cmdline/autoprop_tests.py (original)
+++ subversion/branches/fsfs-format7/subversion/tests/cmdline/autoprop_tests.py Sat Apr 27 21:30:36 2013
@@ -635,7 +635,7 @@ def svn_prop_inheritable_autoprops_add_v
   # again, which is not what we are here to test.
   if os.name == 'posix':
     os.chmod(os.path.join(sbox.wc_dir, 'D', 'rip.bat'), 0664)
-    
+
   os.chdir(sbox.wc_dir)
   svntest.main.run_svn(None, 'add', '.', '--force', '--no-auto-props',
                        '--config-dir', config_dir)

Modified: subversion/branches/fsfs-format7/subversion/tests/cmdline/basic_tests.py
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/tests/cmdline/basic_tests.py?rev=1476675&r1=1476674&r2=1476675&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/tests/cmdline/basic_tests.py (original)
+++ subversion/branches/fsfs-format7/subversion/tests/cmdline/basic_tests.py Sat Apr 27 21:30:36 2013
@@ -3043,12 +3043,12 @@ def peg_rev_on_non_existent_wc_path(sbox
   # test something.
   sbox.simple_update()
   # This currently fails with ENOENT on A/mu3.
-  svntest.actions.run_and_verify_svn(None, ['r2\n'], [], 
+  svntest.actions.run_and_verify_svn(None, ['r2\n'], [],
                                      'cat', '-r2', sbox.ospath('A3/mu3') + '@3')
   os.chdir(sbox.ospath('A4'))
-  svntest.actions.run_and_verify_svn(None, ['r2\n'], [], 
+  svntest.actions.run_and_verify_svn(None, ['r2\n'], [],
                                      'cat', '-r2', sbox.ospath('mu3') + '@3')
-  
+
 ########################################################################
 # Run the tests
 

Modified: subversion/branches/fsfs-format7/subversion/tests/cmdline/blame_tests.py
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/tests/cmdline/blame_tests.py?rev=1476675&r1=1476674&r2=1476675&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/tests/cmdline/blame_tests.py (original)
+++ subversion/branches/fsfs-format7/subversion/tests/cmdline/blame_tests.py Sat Apr 27 21:30:36 2013
@@ -150,7 +150,7 @@ def blame_binary(sbox):
   svntest.main.run_svn(None, 'propdel', 'svn:mime-type', iota)
   svntest.main.run_svn(None, 'ci',
                        '-m', '', iota)
-  
+
   # Blame fails when asking about an old revision where the mime-type is binary
   exit_code, output, errput = svntest.main.run_svn(2, 'blame', iota + '@3')
   if (len(errput) != 1) or (errput[0].find('Skipping') == -1):

Modified: subversion/branches/fsfs-format7/subversion/tests/cmdline/cat_tests.py
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/tests/cmdline/cat_tests.py?rev=1476675&r1=1476674&r2=1476675&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/tests/cmdline/cat_tests.py (original)
+++ subversion/branches/fsfs-format7/subversion/tests/cmdline/cat_tests.py Sat Apr 27 21:30:36 2013
@@ -163,6 +163,8 @@ def cat_skip_uncattable(sbox):
   expected_err_re = re.compile(expected_err3, re.DOTALL)
 
   exit_code, output, error = svntest.main.run_svn(1, 'cat', rho_path, G_path, new_file_path)
+  error = [line for line in error
+           if not re.compile(svntest.main.stack_trace_regexp).match(line)]
 
   # Verify output
   if output[0] != expected_out:

Modified: subversion/branches/fsfs-format7/subversion/tests/cmdline/commit_tests.py
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/tests/cmdline/commit_tests.py?rev=1476675&r1=1476674&r2=1476675&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/tests/cmdline/commit_tests.py (original)
+++ subversion/branches/fsfs-format7/subversion/tests/cmdline/commit_tests.py Sat Apr 27 21:30:36 2013
@@ -2892,7 +2892,7 @@ def commit_danglers(sbox):
   A_copied = sbox.ospath('A_copied')
   mu_copied = sbox.ospath('A_copied/mu')
 
-  svntest.main.file_write(mu_copied, "xxxx")  
+  svntest.main.file_write(mu_copied, "xxxx")
 
   # We already test for this problem for some time
   expected_error = "svn: E200009: '.*A_copied' .*exist.*yet.* '.*mu'.*part"
@@ -2936,16 +2936,16 @@ def last_changed_of_copied_subdir(sbox):
   E_copied = sbox.ospath('A/B_copied/E')
   alpha_copied = sbox.ospath('A/B_copied/E/alpha')
 
-  svntest.main.file_write(alpha_copied, "xxxx") 
-  
+  svntest.main.file_write(alpha_copied, "xxxx")
+
   svntest.main.run_svn(None, 'commit', wc_dir, '-mm')
 
   expected = {'Revision'          : '2',
               'Last Changed Rev'  : '2',
              }
   svntest.actions.run_and_verify_info([expected], E_copied)
-  
-  
+
+
 ########################################################################
 # Run the tests
 

Modified: subversion/branches/fsfs-format7/subversion/tests/cmdline/copy_tests.py
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/tests/cmdline/copy_tests.py?rev=1476675&r1=1476674&r2=1476675&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/tests/cmdline/copy_tests.py (original)
+++ subversion/branches/fsfs-format7/subversion/tests/cmdline/copy_tests.py Sat Apr 27 21:30:36 2013
@@ -4749,7 +4749,7 @@ def mixed_rev_copy_del(sbox):
                                         '-r1',
                                         sbox.ospath('A/B/E/alpha'),
                                         sbox.ospath('A/B/E/beta'))
-  
+
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
 
   # Copy A/B/E to A/B/E_copy
@@ -5217,7 +5217,7 @@ def case_only_rename(sbox):
   # Create expected status.
   expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
   expected_status.add({
-  
+
     'iota'              : Item(status='D ', wc_rev=1, moved_to='IoTa'),
     'IoTa'              : Item(status='A ', copied='+', wc_rev='-', moved_from='iota'),
     'A/B'               : Item(status='D ', wc_rev='1', moved_to='A/b'),

Modified: subversion/branches/fsfs-format7/subversion/tests/cmdline/depth_tests.py
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/tests/cmdline/depth_tests.py?rev=1476675&r1=1476674&r2=1476675&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/tests/cmdline/depth_tests.py (original)
+++ subversion/branches/fsfs-format7/subversion/tests/cmdline/depth_tests.py Sat Apr 27 21:30:36 2013
@@ -2867,9 +2867,9 @@ def revert_depth_files(sbox):
   "depth immediate+files should revert deleted files"
 
   sbox.build(read_only = True)
-  
+
   expected_output = "Reverted '" + re.escape(sbox.ospath('A/mu')) + "'"
-  
+
   # Apply an unrelated delete one level to deep
   sbox.simple_rm('A/D/gamma')
 

Modified: subversion/branches/fsfs-format7/subversion/tests/cmdline/diff_tests.py
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/tests/cmdline/diff_tests.py?rev=1476675&r1=1476674&r2=1476675&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/tests/cmdline/diff_tests.py (original)
+++ subversion/branches/fsfs-format7/subversion/tests/cmdline/diff_tests.py Sat Apr 27 21:30:36 2013
@@ -3388,7 +3388,7 @@ def diff_git_format_wc_wc(sbox):
   expected_output = make_git_diff_header(
                          alpha_copied_path, "A/B/E/alpha_copied",
                          "revision 0", "working copy",
-                         copyfrom_path="A/B/E/alpha", 
+                         copyfrom_path="A/B/E/alpha",
                          copyfrom_rev='1', cp=True,
                          text_changes=True) + [
     "@@ -1 +1,2 @@\n",
@@ -3983,7 +3983,7 @@ def diff_two_working_copies(sbox):
                       "@@ -1 +0,0 @@\n",
                       "-This is the file 'psi'.\n",
                     ]
-                    
+
   # Files in diff may be in any order.
   expected_output = svntest.verify.UnorderedOutput(expected_output)
   svntest.actions.run_and_verify_svn(None, expected_output, [],

Modified: subversion/branches/fsfs-format7/subversion/tests/cmdline/export_tests.py
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/tests/cmdline/export_tests.py?rev=1476675&r1=1476674&r2=1476675&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/tests/cmdline/export_tests.py (original)
+++ subversion/branches/fsfs-format7/subversion/tests/cmdline/export_tests.py Sat Apr 27 21:30:36 2013
@@ -918,6 +918,52 @@ def export_file_overwrite_with_force(sbo
                                      iota_url, tmpdir)
   svntest.actions.verify_disk(tmpdir, expected_disk)
 
+def export_custom_keywords(sbox):
+  """export with custom keywords"""
+
+  sbox.build()
+  wc_dir = sbox.wc_dir
+
+  # 248=SVN_KEYWORD_MAX_LEN-7 where 7 is '$', 'Q', 'q', ':', ' ', ' ', '$'
+  alpha_content = ('[$Qq: %s $ $Pp: %s $]\n'
+                   % (sbox.repo_url[:248],
+                      (sbox.repo_url + '/A/B/E/alpha')[:248]))
+
+  sbox.simple_append('A/B/E/alpha', '[$Qq$ $Pp$]\n', truncate=True)
+  sbox.simple_propset('svn:keywords', 'Qq=%R Pp=%u', 'A/B/E/alpha')
+  sbox.simple_commit()
+  expected_disk = svntest.main.greek_state.copy()
+  expected_disk.tweak('A/B/E/alpha', contents=alpha_content)
+  svntest.actions.verify_disk(sbox.wc_dir, expected_disk)
+
+  # Export a tree
+  export_target = sbox.add_wc_path('export')
+  expected_output = svntest.wc.State(export_target, {
+    ''             : Item(status='A '),
+    'alpha'       : Item(status='A '),
+    'beta'        : Item(status='A '),
+  })
+  expected_disk = svntest.wc.State('', {
+      'alpha': Item(contents=alpha_content),
+      'beta' : Item(contents="This is the file 'beta'.\n"),
+      })
+  svntest.actions.run_and_verify_export(sbox.repo_url + '/A/B/E',
+                                        export_target,
+                                        expected_output,
+                                        expected_disk)
+
+  # Export a file
+  export_file = os.path.join(export_target, 'alpha')
+  os.remove(export_file)
+  expected_output = ['A    %s\n' % export_file, 'Export complete.\n']
+  svntest.actions.run_and_verify_svn(None, expected_output, [],
+                                     'export', '--force',
+                                     sbox.repo_url + '/A/B/E/alpha',
+                                     export_target)
+
+  if open(export_file).read() != ''.join(alpha_content):
+    raise svntest.Failure("wrong keyword expansion")
+
 ########################################################################
 # Run the tests
 
@@ -951,6 +997,7 @@ test_list = [ None,
               export_externals_with_native_eol,
               export_to_current_dir,
               export_file_overwrite_with_force,
+              export_custom_keywords,
              ]
 
 if __name__ == '__main__':

Modified: subversion/branches/fsfs-format7/subversion/tests/cmdline/externals_tests.py
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/tests/cmdline/externals_tests.py?rev=1476675&r1=1476674&r2=1476675&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/tests/cmdline/externals_tests.py (original)
+++ subversion/branches/fsfs-format7/subversion/tests/cmdline/externals_tests.py Sat Apr 27 21:30:36 2013
@@ -2556,7 +2556,7 @@ def commit_include_externals(sbox):
 
 
   # Assume everything r4, except what is pegged
-  expected_status.tweak(wc_rev='4')  
+  expected_status.tweak(wc_rev='4')
   expected_status.tweak('Xpegged/xiota', 'Xpegged/xE', 'Xpegged/xE/alpha',
                         'Xpegged/xE/beta', wc_rev=1)
 
@@ -2781,7 +2781,7 @@ def include_immediate_dir_externals(sbox
   #
   #   >svn st
   #   X       X\XE
-  #   
+  #
   #   Performing status on external item at 'X\XE':
   #    M      C:\SVN\src-trunk\...\externals_tests-37\X\XE
   #   M       C:\SVN\src-trunk\...\externals_tests-37\X\XE\alpha
@@ -3048,15 +3048,15 @@ def duplicate_targets(sbox):
   actions.run_and_verify_svn2('OUTPUT', expected_stdout, [], 0, 'pg',
     'svn:externals', wc_dir)
 
-@Issue(4225)  
+@Issue(4225)
 def list_include_externals(sbox):
   "list with --include-externals"
-  
+
   externals_test_setup(sbox)
 
   wc_dir         = sbox.wc_dir
   repo_url       = sbox.repo_url
-  
+
   svntest.actions.run_and_verify_svn(None, None, [],
                                      'checkout',
                                      repo_url, wc_dir)
@@ -3073,7 +3073,7 @@ def list_include_externals(sbox):
     return string
 
   expected_stdout = verify.UnorderedOutput([
-    "E/" + "\n", 
+    "E/" + "\n",
     "F/" + "\n",
     "lambda" + "\n",
     list_external_string("gamma", B_url ) + "\n",
@@ -3081,7 +3081,7 @@ def list_include_externals(sbox):
 
   exit_code, stdout, stderr = svntest.actions.run_and_verify_svn2(
     "OUTPUT", expected_stdout, [], 0, 'ls', '--include-externals', B_path)
-  
+
   exit_code, stdout, stderr = svntest.actions.run_and_verify_svn2(
     "OUTPUT", expected_stdout, [], 0, 'ls', '--include-externals', B_url)
 
@@ -3094,10 +3094,10 @@ def list_include_externals(sbox):
     "chi" + "\n",
     "omega" + "\n",
     "psi" + "\n"])
-  
+
   exit_code, stdout, stderr = svntest.actions.run_and_verify_svn2(
     "OUTPUT", expected_stdout, [], 0, 'ls', '--include-externals', C_path)
-  
+
   exit_code, stdout, stderr = svntest.actions.run_and_verify_svn2(
     "OUTPUT", expected_stdout, [], 0, 'ls', '--include-externals', C_url)
 

Modified: subversion/branches/fsfs-format7/subversion/tests/cmdline/import_tests.py
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/tests/cmdline/import_tests.py?rev=1476675&r1=1476674&r2=1476675&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/tests/cmdline/import_tests.py (original)
+++ subversion/branches/fsfs-format7/subversion/tests/cmdline/import_tests.py Sat Apr 27 21:30:36 2013
@@ -554,7 +554,7 @@ def import_inherited_ignores(sbox):
   svntest.actions.run_and_verify_svn(None, [], [], 'import',
                                      '--config-dir', config_dir,
                                      os.path.join(import_tree_dir,
-                                                  'DIR6', 'file6.foo'), 
+                                                  'DIR6', 'file6.foo'),
                                      sbox.repo_url + '/A/B/E/file6.foo',
                                      '-m', 'This import should fail!')
 
@@ -563,7 +563,7 @@ def import_inherited_ignores(sbox):
   svntest.actions.run_and_verify_svn(None, None, [], 'import', '--no-ignore',
                                      '--config-dir', config_dir,
                                      os.path.join(import_tree_dir,
-                                                  'DIR6', 'file6.foo'), 
+                                                  'DIR6', 'file6.foo'),
                                      sbox.repo_url + '/A/B/E/file6.foo',
                                      '-m', 'import')
   expected_output = svntest.verify.UnorderedOutput(

Modified: subversion/branches/fsfs-format7/subversion/tests/cmdline/info_tests.py
URL: http://svn.apache.org/viewvc/subversion/branches/fsfs-format7/subversion/tests/cmdline/info_tests.py?rev=1476675&r1=1476674&r2=1476675&view=diff
==============================================================================
--- subversion/branches/fsfs-format7/subversion/tests/cmdline/info_tests.py (original)
+++ subversion/branches/fsfs-format7/subversion/tests/cmdline/info_tests.py Sat Apr 27 21:30:36 2013
@@ -544,7 +544,7 @@ def relpath_escaping(sbox):
               'URL' : '.*/path.*with.*space.*',
               'Relative URL' : '.*/path.*with.*space.*',
              }
-             
+
   svntest.actions.run_and_verify_info([expected], sbox.ospath(name))
 
   info = svntest.actions.run_and_parse_info(sbox.ospath(name), sbox.ospath(name2))



Mime
View raw message