subversion-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From prabh...@apache.org
Subject svn commit: r1489765 [9/22] - in /subversion/branches/verify-keep-going: ./ build/ build/ac-macros/ build/generator/ build/generator/templates/ contrib/hook-scripts/ contrib/server-side/fsfsfixer/ contrib/server-side/fsfsfixer/fixer/ notes/ subversion/...
Date Wed, 05 Jun 2013 09:22:51 GMT
Modified: subversion/branches/verify-keep-going/subversion/libsvn_ra_svn/client.c
URL: http://svn.apache.org/viewvc/subversion/branches/verify-keep-going/subversion/libsvn_ra_svn/client.c?rev=1489765&r1=1489764&r2=1489765&view=diff
==============================================================================
--- subversion/branches/verify-keep-going/subversion/libsvn_ra_svn/client.c (original)
+++ subversion/branches/verify-keep-going/subversion/libsvn_ra_svn/client.c Wed Jun  5 09:22:43 2013
@@ -50,6 +50,7 @@
 #include "svn_private_config.h"
 
 #include "private/svn_fspath.h"
+#include "private/svn_subr_private.h"
 
 #include "../libsvn_ra/ra_loader.h"
 
@@ -203,8 +204,8 @@ static svn_error_t *parse_prop_diffs(con
         return svn_error_create(SVN_ERR_RA_SVN_MALFORMED_DATA, NULL,
                                 _("Prop diffs element not a list"));
       prop = apr_array_push(*diffs);
-      SVN_ERR(svn_ra_svn_parse_tuple(elt->u.list, pool, "c(?s)", &prop->name,
-                                     &prop->value));
+      SVN_ERR(svn_ra_svn__parse_tuple(elt->u.list, pool, "c(?s)", &prop->name,
+                                      &prop->value));
     }
   return SVN_NO_ERROR;
 }
@@ -216,9 +217,9 @@ static svn_error_t *parse_lock(const apr
 {
   const char *cdate, *edate;
   *lock = svn_lock_create(pool);
-  SVN_ERR(svn_ra_svn_parse_tuple(list, pool, "ccc(?c)c(?c)", &(*lock)->path,
-                                 &(*lock)->token, &(*lock)->owner,
-                                 &(*lock)->comment, &cdate, &edate));
+  SVN_ERR(svn_ra_svn__parse_tuple(list, pool, "ccc(?c)c(?c)", &(*lock)->path,
+                                  &(*lock)->token, &(*lock)->owner,
+                                  &(*lock)->comment, &cdate, &edate));
   (*lock)->path = svn_fspath__canonicalize((*lock)->path, pool);
   SVN_ERR(svn_time_from_cstring(&(*lock)->creation_date, cdate, pool));
   if (edate)
@@ -232,7 +233,7 @@ svn_error_t *svn_ra_svn__auth_response(s
                                        apr_pool_t *pool,
                                        const char *mech, const char *mech_arg)
 {
-  return svn_ra_svn_write_tuple(conn, pool, "w(?c)", mech, mech_arg);
+  return svn_ra_svn__write_tuple(conn, pool, "w(?c)", mech, mech_arg);
 }
 
 static svn_error_t *handle_auth_request(svn_ra_svn__session_baton_t *sess,
@@ -242,7 +243,7 @@ static svn_error_t *handle_auth_request(
   apr_array_header_t *mechlist;
   const char *realm;
 
-  SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, "lc", &mechlist, &realm));
+  SVN_ERR(svn_ra_svn__read_cmd_response(conn, pool, "lc", &mechlist, &realm));
   if (mechlist->nelts == 0)
     return SVN_NO_ERROR;
   return DO_AUTH(sess, mechlist, realm, pool);
@@ -259,8 +260,8 @@ static svn_error_t *ra_svn_set_path(void
 {
   ra_svn_reporter_baton_t *b = baton;
 
-  SVN_ERR(svn_ra_svn_write_cmd_set_path(b->conn, pool, path, rev,
-                                        start_empty, lock_token, depth));
+  SVN_ERR(svn_ra_svn__write_cmd_set_path(b->conn, pool, path, rev,
+                                         start_empty, lock_token, depth));
   return SVN_NO_ERROR;
 }
 
@@ -269,7 +270,7 @@ static svn_error_t *ra_svn_delete_path(v
 {
   ra_svn_reporter_baton_t *b = baton;
 
-  SVN_ERR(svn_ra_svn_write_cmd_delete_path(b->conn, pool, path));
+  SVN_ERR(svn_ra_svn__write_cmd_delete_path(b->conn, pool, path));
   return SVN_NO_ERROR;
 }
 
@@ -283,8 +284,8 @@ static svn_error_t *ra_svn_link_path(voi
 {
   ra_svn_reporter_baton_t *b = baton;
 
-  SVN_ERR(svn_ra_svn_write_cmd_link_path(b->conn, pool, path, url, rev,
-                                         start_empty, lock_token, depth));
+  SVN_ERR(svn_ra_svn__write_cmd_link_path(b->conn, pool, path, url, rev,
+                                          start_empty, lock_token, depth));
   return SVN_NO_ERROR;
 }
 
@@ -293,11 +294,11 @@ static svn_error_t *ra_svn_finish_report
 {
   ra_svn_reporter_baton_t *b = baton;
 
-  SVN_ERR(svn_ra_svn_write_cmd_finish_report(b->conn, b->pool));
+  SVN_ERR(svn_ra_svn__write_cmd_finish_report(b->conn, b->pool));
   SVN_ERR(handle_auth_request(b->sess_baton, b->pool));
   SVN_ERR(svn_ra_svn_drive_editor2(b->conn, b->pool, b->editor, b->edit_baton,
                                    NULL, FALSE));
-  SVN_ERR(svn_ra_svn_read_cmd_response(b->conn, b->pool, ""));
+  SVN_ERR(svn_ra_svn__read_cmd_response(b->conn, b->pool, ""));
   return SVN_NO_ERROR;
 }
 
@@ -306,7 +307,7 @@ static svn_error_t *ra_svn_abort_report(
 {
   ra_svn_reporter_baton_t *b = baton;
 
-  SVN_ERR(svn_ra_svn_write_cmd_abort_report(b->conn, b->pool));
+  SVN_ERR(svn_ra_svn__write_cmd_abort_report(b->conn, b->pool));
   return SVN_NO_ERROR;
 }
 
@@ -461,9 +462,9 @@ static void handle_child_process_error(a
                                  SVN_DELTA_COMPRESSION_LEVEL_DEFAULT, 0,
                                  0, pool);
   err = svn_error_wrap_apr(status, _("Error in child process: %s"), desc);
-  svn_error_clear(svn_ra_svn_write_cmd_failure(conn, pool, err));
+  svn_error_clear(svn_ra_svn__write_cmd_failure(conn, pool, err));
   svn_error_clear(err);
-  svn_error_clear(svn_ra_svn_flush(conn, pool));
+  svn_error_clear(svn_ra_svn__flush(conn, pool));
 }
 
 /* (Note: *CONN is an output parameter.) */
@@ -531,7 +532,7 @@ static svn_error_t *make_tunnel(const ch
   *conn = svn_ra_svn_create_conn3(NULL, proc->out, proc->in,
                                   SVN_DELTA_COMPRESSION_LEVEL_DEFAULT,
                                   0, 0, pool);
-  err = svn_ra_svn_skip_leading_garbage(*conn, pool);
+  err = svn_ra_svn__skip_leading_garbage(*conn, pool);
   if (err)
     return svn_error_quick_wrap(
              err,
@@ -593,7 +594,7 @@ static svn_error_t *open_session(svn_ra_
   sess->callbacks = callbacks;
   sess->callbacks_baton = callbacks_baton;
   sess->bytes_read = sess->bytes_written = 0;
-  
+
   if (tunnel_argv)
     SVN_ERR(make_tunnel(tunnel_argv, &conn, pool));
   else
@@ -627,8 +628,8 @@ static svn_error_t *open_session(svn_ra_
   conn->session = sess;
 
   /* Read server's greeting. */
-  SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, "nnll", &minver, &maxver,
-                                       &mechlist, &server_caplist));
+  SVN_ERR(svn_ra_svn__read_cmd_response(conn, pool, "nnll", &minver, &maxver,
+                                        &mechlist, &server_caplist));
 
   /* We support protocol version 2. */
   if (minver > 2)
@@ -651,17 +652,17 @@ static svn_error_t *open_session(svn_ra_
    * capability list, and the URL, and subsequently there is an auth
    * request. */
   /* Client-side capabilities list: */
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "n(wwwwww)cc(?c)",
-                                 (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_DEPTH,
-                                 SVN_RA_SVN_CAP_MERGEINFO,
-                                 SVN_RA_SVN_CAP_LOG_REVPROPS,
-                                 url,
-                                 SVN_RA_SVN__DEFAULT_USERAGENT,
-                                 client_string));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "n(wwwwww)cc(?c)",
+                                  (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_DEPTH,
+                                  SVN_RA_SVN_CAP_MERGEINFO,
+                                  SVN_RA_SVN_CAP_LOG_REVPROPS,
+                                  url,
+                                  SVN_RA_SVN__DEFAULT_USERAGENT,
+                                  client_string));
   SVN_ERR(handle_auth_request(sess, pool));
 
   /* This is where the security layer would go into effect if we
@@ -669,8 +670,8 @@ static svn_error_t *open_session(svn_ra_
 
   /* Read the repository's uuid and root URL, and perhaps learn more
      capabilities that weren't available before now. */
-  SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, "c?c?l", &conn->uuid,
-                                       &conn->repos_root, &repos_caplist));
+  SVN_ERR(svn_ra_svn__read_cmd_response(conn, pool, "c?c?l", &conn->uuid,
+                                        &conn->repos_root, &repos_caplist));
   if (repos_caplist)
     SVN_ERR(svn_ra_svn_set_capabilities(conn, repos_caplist));
 
@@ -773,11 +774,11 @@ static svn_error_t *ra_svn_reparent(svn_
   svn_ra_svn__session_baton_t *new_sess;
   apr_uri_t uri;
 
-  SVN_ERR(svn_ra_svn_write_cmd_reparent(conn, pool, url));
+  SVN_ERR(svn_ra_svn__write_cmd_reparent(conn, pool, url));
   err = handle_auth_request(sess, pool);
   if (! err)
     {
-      SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, ""));
+      SVN_ERR(svn_ra_svn__read_cmd_response(conn, pool, ""));
       sess->url = apr_pstrdup(sess->pool, url);
       return SVN_NO_ERROR;
     }
@@ -822,9 +823,9 @@ static svn_error_t *ra_svn_get_latest_re
   svn_ra_svn__session_baton_t *sess_baton = session->priv;
   svn_ra_svn_conn_t *conn = sess_baton->conn;
 
-  SVN_ERR(svn_ra_svn_write_cmd_get_latest_rev(conn, pool));
+  SVN_ERR(svn_ra_svn__write_cmd_get_latest_rev(conn, pool));
   SVN_ERR(handle_auth_request(sess_baton, pool));
-  SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, "r", rev));
+  SVN_ERR(svn_ra_svn__read_cmd_response(conn, pool, "r", rev));
   return SVN_NO_ERROR;
 }
 
@@ -835,9 +836,9 @@ static svn_error_t *ra_svn_get_dated_rev
   svn_ra_svn__session_baton_t *sess_baton = session->priv;
   svn_ra_svn_conn_t *conn = sess_baton->conn;
 
-  SVN_ERR(svn_ra_svn_write_cmd_get_dated_rev(conn, pool, tm));
+  SVN_ERR(svn_ra_svn__write_cmd_get_dated_rev(conn, pool, tm));
   SVN_ERR(handle_auth_request(sess_baton, pool));
-  SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, "r", rev));
+  SVN_ERR(svn_ra_svn__read_cmd_response(conn, pool, "r", rev));
   return SVN_NO_ERROR;
 }
 
@@ -878,15 +879,15 @@ static svn_error_t *ra_svn_change_rev_pr
     }
 
   if (has_atomic_revprops)
-    SVN_ERR(svn_ra_svn_write_cmd_change_rev_prop2(conn, pool, rev, name,
-                                                  value, dont_care,
-                                                  old_value));
+    SVN_ERR(svn_ra_svn__write_cmd_change_rev_prop2(conn, pool, rev, name,
+                                                   value, dont_care,
+                                                   old_value));
   else
-    SVN_ERR(svn_ra_svn_write_cmd_change_rev_prop(conn, pool, rev, name,
-                                                 value));
+    SVN_ERR(svn_ra_svn__write_cmd_change_rev_prop(conn, pool, rev, name,
+                                                  value));
 
   SVN_ERR(handle_auth_request(sess_baton, pool));
-  SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, ""));
+  SVN_ERR(svn_ra_svn__read_cmd_response(conn, pool, ""));
   return SVN_NO_ERROR;
 }
 
@@ -920,10 +921,10 @@ static svn_error_t *ra_svn_rev_proplist(
   svn_ra_svn_conn_t *conn = sess_baton->conn;
   apr_array_header_t *proplist;
 
-  SVN_ERR(svn_ra_svn_write_cmd_rev_proplist(conn, pool, rev));
+  SVN_ERR(svn_ra_svn__write_cmd_rev_proplist(conn, pool, rev));
   SVN_ERR(handle_auth_request(sess_baton, pool));
-  SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, "l", &proplist));
-  SVN_ERR(svn_ra_svn_parse_proplist(proplist, pool, props));
+  SVN_ERR(svn_ra_svn__read_cmd_response(conn, pool, "l", &proplist));
+  SVN_ERR(svn_ra_svn__parse_proplist(proplist, pool, props));
   return SVN_NO_ERROR;
 }
 
@@ -934,9 +935,9 @@ static svn_error_t *ra_svn_rev_prop(svn_
   svn_ra_svn__session_baton_t *sess_baton = session->priv;
   svn_ra_svn_conn_t *conn = sess_baton->conn;
 
-  SVN_ERR(svn_ra_svn_write_cmd_rev_prop(conn, pool, rev, name));
+  SVN_ERR(svn_ra_svn__write_cmd_rev_prop(conn, pool, rev, name));
   SVN_ERR(handle_auth_request(sess_baton, pool));
-  SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, "(?s)", value));
+  SVN_ERR(svn_ra_svn__read_cmd_response(conn, pool, "(?s)", value));
   return SVN_NO_ERROR;
 }
 
@@ -946,8 +947,8 @@ static svn_error_t *ra_svn_end_commit(vo
   svn_commit_info_t *commit_info = svn_create_commit_info(ccb->pool);
 
   SVN_ERR(handle_auth_request(ccb->sess_baton, ccb->pool));
-  SVN_ERR(svn_ra_svn_read_tuple(ccb->sess_baton->conn, ccb->pool,
-                                "r(?c)(?c)?(?c)",
+  SVN_ERR(svn_ra_svn__read_tuple(ccb->sess_baton->conn, ccb->pool,
+                                 "r(?c)(?c)?(?c)",
                                  &(commit_info->revision),
                                  &(commit_info->date),
                                  &(commit_info->author),
@@ -999,8 +1000,8 @@ static svn_error_t *ra_svn_commit(svn_ra
   /* Tell the server we're starting the commit.
      Send log message here for backwards compatibility with servers
      before 1.5. */
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "w(c(!", "commit",
-                                 log_msg->data));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "w(c(!", "commit",
+                                  log_msg->data));
   if (lock_tokens)
     {
       iterpool = svn_pool_create(pool);
@@ -1014,15 +1015,15 @@ static svn_error_t *ra_svn_commit(svn_ra
           apr_hash_this(hi, &key, NULL, &val);
           path = key;
           token = val;
-          SVN_ERR(svn_ra_svn_write_tuple(conn, iterpool, "cc", path, token));
+          SVN_ERR(svn_ra_svn__write_tuple(conn, iterpool, "cc", path, token));
         }
       svn_pool_destroy(iterpool);
     }
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!)b(!", keep_locks));
-  SVN_ERR(svn_ra_svn_write_proplist(conn, pool, revprop_table));
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!))"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!)b(!", keep_locks));
+  SVN_ERR(svn_ra_svn__write_proplist(conn, pool, revprop_table));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!))"));
   SVN_ERR(handle_auth_request(sess_baton, pool));
-  SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, ""));
+  SVN_ERR(svn_ra_svn__read_cmd_response(conn, pool, ""));
 
   /* Remember a few arguments for when the commit is over. */
   ccb = apr_palloc(pool, sizeof(*ccb));
@@ -1089,13 +1090,13 @@ parse_iproplist(apr_array_header_t **inh
 
       svn_pool_clear(iterpool);
 
-      SVN_ERR(svn_ra_svn_parse_tuple(elt->u.list, iterpool, "cl",
-                                     &parent_rel_path, &iprop_list));
-      SVN_ERR(svn_ra_svn_parse_proplist(iprop_list, iterpool, &iprops));
+      SVN_ERR(svn_ra_svn__parse_tuple(elt->u.list, iterpool, "cl",
+                                      &parent_rel_path, &iprop_list));
+      SVN_ERR(svn_ra_svn__parse_proplist(iprop_list, iterpool, &iprops));
       new_iprop->path_or_url = svn_path_url_add_component2(repos_root_url,
                                                            parent_rel_path,
                                                            result_pool);
-      new_iprop->prop_hash = apr_hash_make(result_pool);
+      new_iprop->prop_hash = svn_hash__make(result_pool);
       for (hi = apr_hash_first(iterpool, iprops);
            hi;
            hi = apr_hash_next(hi))
@@ -1127,17 +1128,17 @@ static svn_error_t *ra_svn_get_file(svn_
   svn_checksum_ctx_t *checksum_ctx;
   apr_pool_t *iterpool;
 
-  SVN_ERR(svn_ra_svn_write_cmd_get_file(conn, pool, path, rev,
-                                        (props != NULL), (stream != NULL)));
+  SVN_ERR(svn_ra_svn__write_cmd_get_file(conn, pool, path, rev,
+                                         (props != NULL), (stream != NULL)));
   SVN_ERR(handle_auth_request(sess_baton, pool));
-  SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, "(?c)rl",
-                                       &expected_digest,
-                                       &rev, &proplist));
+  SVN_ERR(svn_ra_svn__read_cmd_response(conn, pool, "(?c)rl",
+                                        &expected_digest,
+                                        &rev, &proplist));
 
   if (fetched_rev)
     *fetched_rev = rev;
   if (props)
-    SVN_ERR(svn_ra_svn_parse_proplist(proplist, pool, props));
+    SVN_ERR(svn_ra_svn__parse_proplist(proplist, pool, props));
 
   /* We're done if the contents weren't wanted. */
   if (!stream)
@@ -1157,7 +1158,7 @@ static svn_error_t *ra_svn_get_file(svn_
       svn_ra_svn_item_t *item;
 
       svn_pool_clear(iterpool);
-      SVN_ERR(svn_ra_svn_read_item(conn, iterpool, &item));
+      SVN_ERR(svn_ra_svn__read_item(conn, iterpool, &item));
       if (item->kind != SVN_RA_SVN_STRING)
         return svn_error_create(SVN_ERR_RA_SVN_MALFORMED_DATA, NULL,
                                 _("Non-string as part of file contents"));
@@ -1173,7 +1174,7 @@ static svn_error_t *ra_svn_get_file(svn_
     }
   svn_pool_destroy(iterpool);
 
-  SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, ""));
+  SVN_ERR(svn_ra_svn__read_cmd_response(conn, pool, ""));
 
   if (expected_checksum)
     {
@@ -1203,38 +1204,38 @@ static svn_error_t *ra_svn_get_dir(svn_r
   apr_array_header_t *proplist, *dirlist;
   int i;
 
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "w(c(?r)bb(!", "get-dir", path,
-                                 rev, (props != NULL), (dirents != NULL)));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "w(c(?r)bb(!", "get-dir", path,
+                                  rev, (props != NULL), (dirents != NULL)));
   if (dirent_fields & SVN_DIRENT_KIND)
-    SVN_ERR(svn_ra_svn_write_word(conn, pool, SVN_RA_SVN_DIRENT_KIND));
+    SVN_ERR(svn_ra_svn__write_word(conn, pool, SVN_RA_SVN_DIRENT_KIND));
   if (dirent_fields & SVN_DIRENT_SIZE)
-    SVN_ERR(svn_ra_svn_write_word(conn, pool, SVN_RA_SVN_DIRENT_SIZE));
+    SVN_ERR(svn_ra_svn__write_word(conn, pool, SVN_RA_SVN_DIRENT_SIZE));
   if (dirent_fields & SVN_DIRENT_HAS_PROPS)
-    SVN_ERR(svn_ra_svn_write_word(conn, pool, SVN_RA_SVN_DIRENT_HAS_PROPS));
+    SVN_ERR(svn_ra_svn__write_word(conn, pool, SVN_RA_SVN_DIRENT_HAS_PROPS));
   if (dirent_fields & SVN_DIRENT_CREATED_REV)
-    SVN_ERR(svn_ra_svn_write_word(conn, pool, SVN_RA_SVN_DIRENT_CREATED_REV));
+    SVN_ERR(svn_ra_svn__write_word(conn, pool, SVN_RA_SVN_DIRENT_CREATED_REV));
   if (dirent_fields & SVN_DIRENT_TIME)
-    SVN_ERR(svn_ra_svn_write_word(conn, pool, SVN_RA_SVN_DIRENT_TIME));
+    SVN_ERR(svn_ra_svn__write_word(conn, pool, SVN_RA_SVN_DIRENT_TIME));
   if (dirent_fields & SVN_DIRENT_LAST_AUTHOR)
-    SVN_ERR(svn_ra_svn_write_word(conn, pool, SVN_RA_SVN_DIRENT_LAST_AUTHOR));
+    SVN_ERR(svn_ra_svn__write_word(conn, pool, SVN_RA_SVN_DIRENT_LAST_AUTHOR));
 
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!))"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!))"));
 
   SVN_ERR(handle_auth_request(sess_baton, pool));
-  SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, "rll", &rev, &proplist,
-                                       &dirlist));
+  SVN_ERR(svn_ra_svn__read_cmd_response(conn, pool, "rll", &rev, &proplist,
+                                        &dirlist));
 
   if (fetched_rev)
     *fetched_rev = rev;
   if (props)
-    SVN_ERR(svn_ra_svn_parse_proplist(proplist, pool, props));
+    SVN_ERR(svn_ra_svn__parse_proplist(proplist, pool, props));
 
   /* We're done if dirents aren't wanted. */
   if (!dirents)
     return SVN_NO_ERROR;
 
   /* Interpret the directory list. */
-  *dirents = apr_hash_make(pool);
+  *dirents = svn_hash__make(pool);
   for (i = 0; i < dirlist->nelts; i++)
     {
       const char *name, *kind, *cdate, *cauthor;
@@ -1247,9 +1248,9 @@ static svn_error_t *ra_svn_get_dir(svn_r
       if (elt->kind != SVN_RA_SVN_LIST)
         return svn_error_create(SVN_ERR_RA_SVN_MALFORMED_DATA, NULL,
                                 _("Dirlist element not a list"));
-      SVN_ERR(svn_ra_svn_parse_tuple(elt->u.list, pool, "cwnbr(?c)(?c)",
-                                     &name, &kind, &size, &has_props,
-                                     &crev, &cdate, &cauthor));
+      SVN_ERR(svn_ra_svn__parse_tuple(elt->u.list, pool, "cwnbr(?c)(?c)",
+                                      &name, &kind, &size, &has_props,
+                                      &crev, &cdate, &cauthor));
       name = svn_relpath_canonicalize(name, pool);
       dirent = svn_dirent_create(pool);
       dirent->kind = svn_node_kind_from_word(kind);
@@ -1276,7 +1277,7 @@ static svn_error_t *ra_svn_get_dir(svn_r
 }
 
 /* Converts a apr_uint64_t with values TRUE, FALSE or
-   SVN_RA_SVN_UNSPECIFIED_NUMBER as provided by svn_ra_svn_parse_tuple
+   SVN_RA_SVN_UNSPECIFIED_NUMBER as provided by svn_ra_svn__parse_tuple
    to a svn_tristate_t */
 static svn_tristate_t
 optbool_to_tristate(apr_uint64_t v)
@@ -1306,23 +1307,23 @@ static svn_error_t *ra_svn_get_mergeinfo
   svn_ra_svn_item_t *elt;
   const char *path;
 
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "w((!", "get-mergeinfo"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "w((!", "get-mergeinfo"));
   for (i = 0; i < paths->nelts; i++)
     {
       path = APR_ARRAY_IDX(paths, i, const char *);
-      SVN_ERR(svn_ra_svn_write_cstring(conn, pool, path));
+      SVN_ERR(svn_ra_svn__write_cstring(conn, pool, path));
     }
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!)(?r)wb)", revision,
-                                 svn_inheritance_to_word(inherit),
-                                 include_descendants));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!)(?r)wb)", revision,
+                                  svn_inheritance_to_word(inherit),
+                                  include_descendants));
 
   SVN_ERR(handle_auth_request(sess_baton, pool));
-  SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, "l", &mergeinfo_tuple));
+  SVN_ERR(svn_ra_svn__read_cmd_response(conn, pool, "l", &mergeinfo_tuple));
 
   *catalog = NULL;
   if (mergeinfo_tuple->nelts > 0)
     {
-      *catalog = apr_hash_make(pool);
+      *catalog = svn_hash__make(pool);
       for (i = 0; i < mergeinfo_tuple->nelts; i++)
         {
           svn_mergeinfo_t for_path;
@@ -1332,8 +1333,8 @@ static svn_error_t *ra_svn_get_mergeinfo
           if (elt->kind != SVN_RA_SVN_LIST)
             return svn_error_create(SVN_ERR_RA_SVN_MALFORMED_DATA, NULL,
                                     _("Mergeinfo element is not a list"));
-          SVN_ERR(svn_ra_svn_parse_tuple(elt->u.list, pool, "cc",
-                                         &path, &to_parse));
+          SVN_ERR(svn_ra_svn__parse_tuple(elt->u.list, pool, "cc",
+                                          &path, &to_parse));
           SVN_ERR(svn_mergeinfo_parse(&for_path, to_parse, pool));
           /* Correct for naughty servers that send "relative" paths
              with leading slashes! */
@@ -1360,9 +1361,9 @@ static svn_error_t *ra_svn_update(svn_ra
   svn_boolean_t recurse = DEPTH_TO_RECURSE(depth);
 
   /* Tell the server we want to start an update. */
-  SVN_ERR(svn_ra_svn_write_cmd_update(conn, pool, rev, target, recurse,
-                                      depth, send_copyfrom_args,
-                                      ignore_ancestry));
+  SVN_ERR(svn_ra_svn__write_cmd_update(conn, pool, rev, target, recurse,
+                                       depth, send_copyfrom_args,
+                                       ignore_ancestry));
   SVN_ERR(handle_auth_request(sess_baton, pool));
 
   /* Fetch a reporter for the caller to drive.  The reporter will drive
@@ -1391,9 +1392,9 @@ ra_svn_switch(svn_ra_session_t *session,
   svn_boolean_t recurse = DEPTH_TO_RECURSE(depth);
 
   /* Tell the server we want to start a switch. */
-  SVN_ERR(svn_ra_svn_write_cmd_switch(conn, pool, rev, target, recurse,
-                                      switch_url, depth,
-                                      send_copyfrom_args, ignore_ancestry));
+  SVN_ERR(svn_ra_svn__write_cmd_switch(conn, pool, rev, target, recurse,
+                                       switch_url, depth,
+                                       send_copyfrom_args, ignore_ancestry));
   SVN_ERR(handle_auth_request(sess_baton, pool));
 
   /* Fetch a reporter for the caller to drive.  The reporter will drive
@@ -1416,8 +1417,8 @@ static svn_error_t *ra_svn_status(svn_ra
   svn_boolean_t recurse = DEPTH_TO_RECURSE(depth);
 
   /* Tell the server we want to start a status operation. */
-  SVN_ERR(svn_ra_svn_write_cmd_status(conn, pool, target, recurse, rev,
-                                      depth));
+  SVN_ERR(svn_ra_svn__write_cmd_status(conn, pool, target, recurse, rev,
+                                       depth));
   SVN_ERR(handle_auth_request(sess_baton, pool));
 
   /* Fetch a reporter for the caller to drive.  The reporter will drive
@@ -1443,9 +1444,9 @@ static svn_error_t *ra_svn_diff(svn_ra_s
   svn_boolean_t recurse = DEPTH_TO_RECURSE(depth);
 
   /* Tell the server we want to start a diff. */
-  SVN_ERR(svn_ra_svn_write_cmd_diff(conn, pool, rev, target, recurse,
-                                    ignore_ancestry, versus_url,
-                                    text_deltas, depth));
+  SVN_ERR(svn_ra_svn__write_cmd_diff(conn, pool, rev, target, recurse,
+                                     ignore_ancestry, versus_url,
+                                     text_deltas, depth));
   SVN_ERR(handle_auth_request(sess_baton, pool));
 
   /* Fetch a reporter for the caller to drive.  The reporter will drive
@@ -1475,39 +1476,50 @@ static svn_error_t *ra_svn_log(svn_ra_se
   const char *path;
   char *name;
   svn_boolean_t want_custom_revprops;
+  svn_boolean_t want_author = FALSE;
+  svn_boolean_t want_message = FALSE;
+  svn_boolean_t want_date = FALSE;
 
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "w((!", "log"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "w((!", "log"));
   if (paths)
     {
       for (i = 0; i < paths->nelts; i++)
         {
           path = APR_ARRAY_IDX(paths, i, const char *);
-          SVN_ERR(svn_ra_svn_write_cstring(conn, pool, path));
+          SVN_ERR(svn_ra_svn__write_cstring(conn, pool, path));
         }
     }
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!)(?r)(?r)bbnb!", start, end,
-                                 discover_changed_paths, strict_node_history,
-                                 (apr_uint64_t) limit,
-                                 include_merged_revisions));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!)(?r)(?r)bbnb!", start, end,
+                                  discover_changed_paths, strict_node_history,
+                                  (apr_uint64_t) limit,
+                                  include_merged_revisions));
   if (revprops)
     {
       want_custom_revprops = FALSE;
-      SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!w(!", "revprops"));
+      SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!w(!", "revprops"));
       for (i = 0; i < revprops->nelts; i++)
         {
           name = APR_ARRAY_IDX(revprops, i, char *);
-          SVN_ERR(svn_ra_svn_write_cstring(conn, pool, name));
-          if (!want_custom_revprops
-              && strcmp(name, SVN_PROP_REVISION_AUTHOR) != 0
-              && strcmp(name, SVN_PROP_REVISION_DATE) != 0
-              && strcmp(name, SVN_PROP_REVISION_LOG) != 0)
+          SVN_ERR(svn_ra_svn__write_cstring(conn, pool, name));
+
+          if (strcmp(name, SVN_PROP_REVISION_AUTHOR) == 0)
+            want_author = TRUE;
+          else if (strcmp(name, SVN_PROP_REVISION_DATE) == 0)
+            want_date = TRUE;
+          else if (strcmp(name, SVN_PROP_REVISION_LOG) == 0)
+            want_message = TRUE;
+          else
             want_custom_revprops = TRUE;
         }
-      SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!))"));
+      SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!))"));
     }
   else
     {
-      SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!w())", "all-revprops"));
+      SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!w())", "all-revprops"));
+
+      want_author = TRUE;
+      want_date = TRUE;
+      want_message = TRUE;
       want_custom_revprops = TRUE;
     }
 
@@ -1531,19 +1543,19 @@ static svn_error_t *ra_svn_log(svn_ra_se
       int nreceived;
 
       svn_pool_clear(iterpool);
-      SVN_ERR(svn_ra_svn_read_item(conn, iterpool, &item));
+      SVN_ERR(svn_ra_svn__read_item(conn, iterpool, &item));
       if (item->kind == SVN_RA_SVN_WORD && strcmp(item->u.word, "done") == 0)
         break;
       if (item->kind != SVN_RA_SVN_LIST)
         return svn_error_create(SVN_ERR_RA_SVN_MALFORMED_DATA, NULL,
                                 _("Log entry not a list"));
-      SVN_ERR(svn_ra_svn_parse_tuple(item->u.list, iterpool,
-                                     "lr(?s)(?s)(?s)?BBnl?B",
-                                     &cplist, &rev, &author, &date,
-                                     &message, &has_children_param,
-                                     &invalid_revnum_param,
-                                     &revprop_count, &rplist,
-                                     &has_subtractive_merge_param));
+      SVN_ERR(svn_ra_svn__parse_tuple(item->u.list, iterpool,
+                                      "lr(?s)(?s)(?s)?BBnl?B",
+                                      &cplist, &rev, &author, &date,
+                                      &message, &has_children_param,
+                                      &invalid_revnum_param,
+                                      &revprop_count, &rplist,
+                                      &has_subtractive_merge_param));
       if (want_custom_revprops && rplist == NULL)
         {
           /* Caller asked for custom revprops, but server is too old. */
@@ -1571,11 +1583,12 @@ static svn_error_t *ra_svn_log(svn_ra_se
       if (cplist->nelts > 0)
         {
           /* Interpret the changed-paths list. */
-          cphash = apr_hash_make(iterpool);
+          cphash = svn_hash__make(iterpool);
           for (i = 0; i < cplist->nelts; i++)
             {
               svn_log_changed_path2_t *change;
-              const char *copy_path, *action, *cpath, *kind_str;
+              svn_string_t *cpath;
+              const char *copy_path, *action, *kind_str;
               apr_uint64_t text_mods, prop_mods;
               svn_revnum_t copy_rev;
               svn_ra_svn_item_t *elt = &APR_ARRAY_IDX(cplist, i,
@@ -1584,14 +1597,20 @@ static svn_error_t *ra_svn_log(svn_ra_se
               if (elt->kind != SVN_RA_SVN_LIST)
                 return svn_error_create(SVN_ERR_RA_SVN_MALFORMED_DATA, NULL,
                                         _("Changed-path entry not a list"));
-              SVN_ERR(svn_ra_svn_parse_tuple(elt->u.list, iterpool,
-                                             "cw(?cr)?(?c?BB)",
-                                             &cpath, &action, &copy_path,
-                                             &copy_rev, &kind_str,
-                                             &text_mods, &prop_mods));
-              cpath = svn_fspath__canonicalize(cpath, iterpool);
-              if (copy_path)
+              SVN_ERR(svn_ra_svn__parse_tuple(elt->u.list, iterpool,
+                                              "sw(?cr)?(?c?BB)",
+                                              &cpath, &action, &copy_path,
+                                              &copy_rev, &kind_str,
+                                              &text_mods, &prop_mods));
+
+              if (!svn_fspath__is_canonical(cpath->data))
+                {
+                  cpath->data = svn_fspath__canonicalize(cpath->data, iterpool);
+                  cpath->len = strlen(cpath->data);
+                }
+              if (copy_path && !svn_fspath__is_canonical(copy_path))
                 copy_path = svn_fspath__canonicalize(copy_path, iterpool);
+
               change = svn_log_changed_path2_create(iterpool);
               change->action = *action;
               change->copyfrom_path = copy_path;
@@ -1599,7 +1618,7 @@ static svn_error_t *ra_svn_log(svn_ra_se
               change->node_kind = svn_node_kind_from_word(kind_str);
               change->text_modified = optbool_to_tristate(text_mods);
               change->props_modified = optbool_to_tristate(prop_mods);
-              svn_hash_sets(cphash, cpath, change);
+              apr_hash_set(cphash, cpath->data, cpath->len, change);
             }
         }
       else
@@ -1616,40 +1635,21 @@ static svn_error_t *ra_svn_log(svn_ra_se
           log_entry->has_children = has_children;
           log_entry->subtractive_merge = subtractive_merge;
           if (rplist)
-            SVN_ERR(svn_ra_svn_parse_proplist(rplist, iterpool,
-                                              &log_entry->revprops));
+            SVN_ERR(svn_ra_svn__parse_proplist(rplist, iterpool,
+                                               &log_entry->revprops));
           if (log_entry->revprops == NULL)
-            log_entry->revprops = apr_hash_make(iterpool);
-          if (revprops == NULL)
-            {
-              /* Caller requested all revprops; set author/date/log. */
-              if (author)
-                svn_hash_sets(log_entry->revprops, SVN_PROP_REVISION_AUTHOR,
-                              author);
-              if (date)
-                svn_hash_sets(log_entry->revprops, SVN_PROP_REVISION_DATE,
-                              date);
-              if (message)
-                svn_hash_sets(log_entry->revprops, SVN_PROP_REVISION_LOG,
-                              message);
-            }
-          else
-            {
-              /* Caller requested some; maybe set author/date/log. */
-              for (i = 0; i < revprops->nelts; i++)
-                {
-                  name = APR_ARRAY_IDX(revprops, i, char *);
-                  if (author && strcmp(name, SVN_PROP_REVISION_AUTHOR) == 0)
-                    svn_hash_sets(log_entry->revprops,
-                                  SVN_PROP_REVISION_AUTHOR, author);
-                  if (date && strcmp(name, SVN_PROP_REVISION_DATE) == 0)
-                    svn_hash_sets(log_entry->revprops,
-                                  SVN_PROP_REVISION_DATE, date);
-                  if (message && strcmp(name, SVN_PROP_REVISION_LOG) == 0)
-                    svn_hash_sets(log_entry->revprops,
-                                  SVN_PROP_REVISION_LOG, message);
-                }
-            }
+            log_entry->revprops = svn_hash__make(iterpool);
+
+          if (author && want_author)
+            svn_hash_sets(log_entry->revprops,
+                          SVN_PROP_REVISION_AUTHOR, author);
+          if (date && want_date)
+            svn_hash_sets(log_entry->revprops,
+                          SVN_PROP_REVISION_DATE, date);
+          if (message && want_message)
+            svn_hash_sets(log_entry->revprops,
+                          SVN_PROP_REVISION_LOG, message);
+
           SVN_ERR(receiver(receiver_baton, log_entry, iterpool));
           if (log_entry->has_children)
             {
@@ -1665,7 +1665,7 @@ static svn_error_t *ra_svn_log(svn_ra_se
   svn_pool_destroy(iterpool);
 
   /* Read the response. */
-  return svn_ra_svn_read_cmd_response(conn, pool, "");
+  return svn_ra_svn__read_cmd_response(conn, pool, "");
 }
 
 
@@ -1677,9 +1677,9 @@ static svn_error_t *ra_svn_check_path(sv
   svn_ra_svn_conn_t *conn = sess_baton->conn;
   const char *kind_word;
 
-  SVN_ERR(svn_ra_svn_write_cmd_check_path(conn, pool, path, rev));
+  SVN_ERR(svn_ra_svn__write_cmd_check_path(conn, pool, path, rev));
   SVN_ERR(handle_auth_request(sess_baton, pool));
-  SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, "w", &kind_word));
+  SVN_ERR(svn_ra_svn__read_cmd_response(conn, pool, "w", &kind_word));
   *kind = svn_node_kind_from_word(kind_word);
   return SVN_NO_ERROR;
 }
@@ -1706,10 +1706,10 @@ static svn_error_t *ra_svn_stat(svn_ra_s
   apr_array_header_t *list = NULL;
   svn_dirent_t *the_dirent;
 
-  SVN_ERR(svn_ra_svn_write_cmd_stat(conn, pool, path, rev));
+  SVN_ERR(svn_ra_svn__write_cmd_stat(conn, pool, path, rev));
   SVN_ERR(handle_unsupported_cmd(handle_auth_request(sess_baton, pool),
                                  N_("'stat' not implemented")));
-  SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, "(?l)", &list));
+  SVN_ERR(svn_ra_svn__read_cmd_response(conn, pool, "(?l)", &list));
 
   if (! list)
     {
@@ -1722,9 +1722,9 @@ static svn_error_t *ra_svn_stat(svn_ra_s
       svn_revnum_t crev;
       apr_uint64_t size;
 
-      SVN_ERR(svn_ra_svn_parse_tuple(list, pool, "wnbr(?c)(?c)",
-                                     &kind, &size, &has_props,
-                                     &crev, &cdate, &cauthor));
+      SVN_ERR(svn_ra_svn__parse_tuple(list, pool, "wnbr(?c)(?c)",
+                                      &kind, &size, &has_props,
+                                      &crev, &cdate, &cauthor));
 
       the_dirent = svn_dirent_create(pool);
       the_dirent->kind = svn_node_kind_from_word(kind);
@@ -1755,15 +1755,15 @@ static svn_error_t *ra_svn_get_locations
   int i;
 
   /* Transmit the parameters. */
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "w(cr(!",
-                                 "get-locations", path, peg_revision));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "w(cr(!",
+                                  "get-locations", path, peg_revision));
   for (i = 0; i < location_revisions->nelts; i++)
     {
       revision = APR_ARRAY_IDX(location_revisions, i, svn_revnum_t);
-      SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!r!", revision));
+      SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!r!", revision));
     }
 
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!))"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!))"));
 
   /* Servers before 1.1 don't support this command. Check for this here. */
   SVN_ERR(handle_unsupported_cmd(handle_auth_request(sess_baton, pool),
@@ -1777,7 +1777,7 @@ static svn_error_t *ra_svn_get_locations
       svn_ra_svn_item_t *item;
       const char *ret_path;
 
-      SVN_ERR(svn_ra_svn_read_item(conn, pool, &item));
+      SVN_ERR(svn_ra_svn__read_item(conn, pool, &item));
       if (item->kind == SVN_RA_SVN_WORD && strcmp(item->u.word, "done") == 0)
         is_done = 1;
       else if (item->kind != SVN_RA_SVN_LIST)
@@ -1785,8 +1785,8 @@ static svn_error_t *ra_svn_get_locations
                                 _("Location entry not a list"));
       else
         {
-          SVN_ERR(svn_ra_svn_parse_tuple(item->u.list, pool, "rc",
-                                         &revision, &ret_path));
+          SVN_ERR(svn_ra_svn__parse_tuple(item->u.list, pool, "rc",
+                                          &revision, &ret_path));
           ret_path = svn_fspath__canonicalize(ret_path, pool);
           apr_hash_set(*locations, apr_pmemdup(pool, &revision,
                                                sizeof(revision)),
@@ -1796,7 +1796,7 @@ static svn_error_t *ra_svn_get_locations
 
   /* Read the response. This is so the server would have a chance to
    * report an error. */
-  return svn_ra_svn_read_cmd_response(conn, pool, "");
+  return svn_ra_svn__read_cmd_response(conn, pool, "");
 }
 
 static svn_error_t *
@@ -1815,9 +1815,9 @@ ra_svn_get_location_segments(svn_ra_sess
   apr_pool_t *iterpool = svn_pool_create(pool);
 
   /* Transmit the parameters. */
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "w(c(?r)(?r)(?r))",
-                                 "get-location-segments",
-                                 path, peg_revision, start_rev, end_rev));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "w(c(?r)(?r)(?r))",
+                                  "get-location-segments",
+                                  path, peg_revision, start_rev, end_rev));
 
   /* Servers before 1.5 don't support this command. Check for this here. */
   SVN_ERR(handle_unsupported_cmd(handle_auth_request(sess_baton, pool),
@@ -1833,7 +1833,7 @@ ra_svn_get_location_segments(svn_ra_sess
       const char *ret_path;
 
       svn_pool_clear(iterpool);
-      SVN_ERR(svn_ra_svn_read_item(conn, iterpool, &item));
+      SVN_ERR(svn_ra_svn__read_item(conn, iterpool, &item));
       if (item->kind == SVN_RA_SVN_WORD && strcmp(item->u.word, "done") == 0)
         is_done = 1;
       else if (item->kind != SVN_RA_SVN_LIST)
@@ -1843,8 +1843,8 @@ ra_svn_get_location_segments(svn_ra_sess
         {
           svn_location_segment_t *segment = apr_pcalloc(iterpool,
                                                         sizeof(*segment));
-          SVN_ERR(svn_ra_svn_parse_tuple(item->u.list, iterpool, "rr(?c)",
-                                         &range_start, &range_end, &ret_path));
+          SVN_ERR(svn_ra_svn__parse_tuple(item->u.list, iterpool, "rr(?c)",
+                                          &range_start, &range_end, &ret_path));
           if (! (SVN_IS_VALID_REVNUM(range_start)
                  && SVN_IS_VALID_REVNUM(range_end)))
             return svn_error_create(SVN_ERR_RA_SVN_MALFORMED_DATA, NULL,
@@ -1861,7 +1861,7 @@ ra_svn_get_location_segments(svn_ra_sess
 
   /* Read the response. This is so the server would have a chance to
    * report an error. */
-  SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, ""));
+  SVN_ERR(svn_ra_svn__read_cmd_response(conn, pool, ""));
 
   return SVN_NO_ERROR;
 }
@@ -1883,9 +1883,9 @@ static svn_error_t *ra_svn_get_file_revs
   rev_pool = svn_pool_create(pool);
   chunk_pool = svn_pool_create(pool);
 
-  SVN_ERR(svn_ra_svn_write_cmd_get_file_revs(sess_baton->conn, pool,
-                                             path, start, end,
-                                             include_merged_revisions));
+  SVN_ERR(svn_ra_svn__write_cmd_get_file_revs(sess_baton->conn, pool,
+                                              path, start, end,
+                                              include_merged_revisions));
 
   /* Servers before 1.1 don't support this command.  Check for this here. */
   SVN_ERR(handle_unsupported_cmd(handle_auth_request(sess_baton, pool),
@@ -1906,7 +1906,7 @@ static svn_error_t *ra_svn_get_file_revs
 
       svn_pool_clear(rev_pool);
       svn_pool_clear(chunk_pool);
-      SVN_ERR(svn_ra_svn_read_item(sess_baton->conn, rev_pool, &item));
+      SVN_ERR(svn_ra_svn__read_item(sess_baton->conn, rev_pool, &item));
       if (item->kind == SVN_RA_SVN_WORD && strcmp(item->u.word, "done") == 0)
         break;
       /* Either we've got a correct revision or we will error out below. */
@@ -1915,11 +1915,11 @@ static svn_error_t *ra_svn_get_file_revs
         return svn_error_create(SVN_ERR_RA_SVN_MALFORMED_DATA, NULL,
                                 _("Revision entry not a list"));
 
-      SVN_ERR(svn_ra_svn_parse_tuple(item->u.list, rev_pool,
-                                     "crll?B", &p, &rev, &rev_proplist,
-                                     &proplist, &merged_rev_param));
+      SVN_ERR(svn_ra_svn__parse_tuple(item->u.list, rev_pool,
+                                      "crll?B", &p, &rev, &rev_proplist,
+                                      &proplist, &merged_rev_param));
       p = svn_fspath__canonicalize(p, rev_pool);
-      SVN_ERR(svn_ra_svn_parse_proplist(rev_proplist, rev_pool, &rev_props));
+      SVN_ERR(svn_ra_svn__parse_proplist(rev_proplist, rev_pool, &rev_props));
       SVN_ERR(parse_prop_diffs(proplist, rev_pool, &props));
       if (merged_rev_param == SVN_RA_SVN_UNSPECIFIED_NUMBER)
         merged_rev = FALSE;
@@ -1927,7 +1927,7 @@ static svn_error_t *ra_svn_get_file_revs
         merged_rev = (svn_boolean_t) merged_rev_param;
 
       /* Get the first delta chunk so we know if there is a delta. */
-      SVN_ERR(svn_ra_svn_read_item(sess_baton->conn, chunk_pool, &item));
+      SVN_ERR(svn_ra_svn__read_item(sess_baton->conn, chunk_pool, &item));
       if (item->kind != SVN_RA_SVN_STRING)
         return svn_error_create(SVN_ERR_RA_SVN_MALFORMED_DATA, NULL,
                                 _("Text delta chunk not a string"));
@@ -1956,8 +1956,8 @@ static svn_error_t *ra_svn_get_file_revs
                 SVN_ERR(svn_stream_write(stream, item->u.string->data, &size));
               svn_pool_clear(chunk_pool);
 
-              SVN_ERR(svn_ra_svn_read_item(sess_baton->conn, chunk_pool,
-                                           &item));
+              SVN_ERR(svn_ra_svn__read_item(sess_baton->conn, chunk_pool,
+                                            &item));
               if (item->kind != SVN_RA_SVN_STRING)
                 return svn_error_create(SVN_ERR_RA_SVN_MALFORMED_DATA, NULL,
                                         _("Text delta chunk not a string"));
@@ -1967,7 +1967,7 @@ static svn_error_t *ra_svn_get_file_revs
         }
     }
 
-  SVN_ERR(svn_ra_svn_read_cmd_response(sess_baton->conn, pool, ""));
+  SVN_ERR(svn_ra_svn__read_cmd_response(sess_baton->conn, pool, ""));
 
   /* Return error if we didn't get any revisions. */
   if (!had_revision)
@@ -2014,15 +2014,15 @@ static svn_error_t *ra_svn_lock_compat(s
       path = key;
       revnum = val;
 
-      SVN_ERR(svn_ra_svn_write_cmd_lock(conn, iterpool, path, comment,
-                                        steal_lock, *revnum));
+      SVN_ERR(svn_ra_svn__write_cmd_lock(conn, iterpool, path, comment,
+                                         steal_lock, *revnum));
 
       /* Servers before 1.2 doesn't support locking.  Check this here. */
       SVN_ERR(handle_unsupported_cmd(handle_auth_request(sess, pool),
                                      N_("Server doesn't support "
                                         "the lock command")));
 
-      err = svn_ra_svn_read_cmd_response(conn, iterpool, "l", &list);
+      err = svn_ra_svn__read_cmd_response(conn, iterpool, "l", &list);
 
       if (!err)
         SVN_ERR(parse_lock(list, iterpool, &lock));
@@ -2078,15 +2078,15 @@ static svn_error_t *ra_svn_unlock_compat
       else
         token = NULL;
 
-      SVN_ERR(svn_ra_svn_write_cmd_unlock(conn, iterpool, path, token,
-                                          break_lock));
+      SVN_ERR(svn_ra_svn__write_cmd_unlock(conn, iterpool, path, token,
+                                           break_lock));
 
       /* Servers before 1.2 don't support locking.  Check this here. */
       SVN_ERR(handle_unsupported_cmd(handle_auth_request(sess, iterpool),
                                      N_("Server doesn't support the unlock "
                                         "command")));
 
-      err = svn_ra_svn_read_cmd_response(conn, iterpool, "");
+      err = svn_ra_svn__read_cmd_response(conn, iterpool, "");
 
       if (err && !SVN_ERR_IS_UNLOCK_ERROR(err))
         return err;
@@ -2121,8 +2121,8 @@ static svn_error_t *ra_svn_lock(svn_ra_s
   svn_error_t *err;
   apr_pool_t *iterpool = svn_pool_create(pool);
 
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "w((?c)b(!", "lock-many",
-                                 comment, steal_lock));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "w((?c)b(!", "lock-many",
+                                  comment, steal_lock));
 
   for (hi = apr_hash_first(pool, path_revs); hi; hi = apr_hash_next(hi))
     {
@@ -2136,10 +2136,10 @@ static svn_error_t *ra_svn_lock(svn_ra_s
       path = key;
       revnum = val;
 
-      SVN_ERR(svn_ra_svn_write_tuple(conn, iterpool, "c(?r)", path, *revnum));
+      SVN_ERR(svn_ra_svn__write_tuple(conn, iterpool, "c(?r)", path, *revnum));
     }
 
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!))"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!))"));
 
   err = handle_auth_request(sess, pool);
 
@@ -2170,7 +2170,7 @@ static svn_error_t *ra_svn_lock(svn_ra_s
       path = key;
 
       svn_pool_clear(iterpool);
-      SVN_ERR(svn_ra_svn_read_item(conn, iterpool, &elt));
+      SVN_ERR(svn_ra_svn__read_item(conn, iterpool, &elt));
 
       /* The server might have encountered some sort of fatal error in
          the middle of the request list.  If this happens, it will
@@ -2183,8 +2183,8 @@ static svn_error_t *ra_svn_lock(svn_ra_s
         return svn_error_create(SVN_ERR_RA_SVN_MALFORMED_DATA, NULL,
                                 _("Lock response not a list"));
 
-      SVN_ERR(svn_ra_svn_parse_tuple(elt->u.list, iterpool, "wl", &status,
-                                     &list));
+      SVN_ERR(svn_ra_svn__parse_tuple(elt->u.list, iterpool, "wl", &status,
+                                      &list));
 
       if (strcmp(status, "failure") == 0)
         err = svn_ra_svn__handle_failure_status(list, iterpool);
@@ -2216,14 +2216,14 @@ static svn_error_t *ra_svn_lock(svn_ra_s
     {
       svn_ra_svn_item_t *elt;
 
-      SVN_ERR(svn_ra_svn_read_item(conn, pool, &elt));
+      SVN_ERR(svn_ra_svn__read_item(conn, pool, &elt));
       if (elt->kind != SVN_RA_SVN_WORD || strcmp(elt->u.word, "done") != 0)
         return svn_error_create(SVN_ERR_RA_SVN_MALFORMED_DATA, NULL,
                                 _("Didn't receive end marker for lock "
                                   "responses"));
     }
 
-  SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, ""));
+  SVN_ERR(svn_ra_svn__read_cmd_response(conn, pool, ""));
 
   svn_pool_destroy(iterpool);
 
@@ -2246,8 +2246,8 @@ static svn_error_t *ra_svn_unlock(svn_ra
   svn_error_t *err;
   const char *path;
 
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "w(b(!", "unlock-many",
-                                 break_lock));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "w(b(!", "unlock-many",
+                                  break_lock));
 
   for (hi = apr_hash_first(pool, path_tokens); hi; hi = apr_hash_next(hi))
     {
@@ -2264,10 +2264,10 @@ static svn_error_t *ra_svn_unlock(svn_ra
       else
         token = NULL;
 
-      SVN_ERR(svn_ra_svn_write_tuple(conn, iterpool, "c(?c)", path, token));
+      SVN_ERR(svn_ra_svn__write_tuple(conn, iterpool, "c(?c)", path, token));
     }
 
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "!))"));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "!))"));
 
   err = handle_auth_request(sess, pool);
 
@@ -2295,7 +2295,7 @@ static svn_error_t *ra_svn_unlock(svn_ra
 
       svn_pool_clear(iterpool);
 
-      SVN_ERR(svn_ra_svn_read_item(conn, iterpool, &elt));
+      SVN_ERR(svn_ra_svn__read_item(conn, iterpool, &elt));
 
       /* The server might have encountered some sort of fatal error in
          the middle of the request list.  If this happens, it will
@@ -2311,14 +2311,14 @@ static svn_error_t *ra_svn_unlock(svn_ra
         return svn_error_create(SVN_ERR_RA_SVN_MALFORMED_DATA, NULL,
                                 _("Unlock response not a list"));
 
-      SVN_ERR(svn_ra_svn_parse_tuple(elt->u.list, iterpool, "wl", &status,
-                                     &list));
+      SVN_ERR(svn_ra_svn__parse_tuple(elt->u.list, iterpool, "wl", &status,
+                                      &list));
 
       if (strcmp(status, "failure") == 0)
         err = svn_ra_svn__handle_failure_status(list, iterpool);
       else if (strcmp(status, "success") == 0)
         {
-          SVN_ERR(svn_ra_svn_parse_tuple(list, iterpool, "c", &path));
+          SVN_ERR(svn_ra_svn__parse_tuple(list, iterpool, "c", &path));
           err = SVN_NO_ERROR;
         }
       else
@@ -2343,14 +2343,14 @@ static svn_error_t *ra_svn_unlock(svn_ra
     {
       svn_ra_svn_item_t *elt;
 
-      SVN_ERR(svn_ra_svn_read_item(conn, pool, &elt));
+      SVN_ERR(svn_ra_svn__read_item(conn, pool, &elt));
       if (elt->kind != SVN_RA_SVN_WORD || strcmp(elt->u.word, "done") != 0)
         return svn_error_create(SVN_ERR_RA_SVN_MALFORMED_DATA, NULL,
                                 _("Didn't receive end marker for unlock "
                                   "responses"));
     }
 
-  SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, ""));
+  SVN_ERR(svn_ra_svn__read_cmd_response(conn, pool, ""));
 
   svn_pool_destroy(iterpool);
 
@@ -2366,14 +2366,14 @@ static svn_error_t *ra_svn_get_lock(svn_
   svn_ra_svn_conn_t* conn = sess->conn;
   apr_array_header_t *list;
 
-  SVN_ERR(svn_ra_svn_write_cmd_get_lock(conn, pool, path));
+  SVN_ERR(svn_ra_svn__write_cmd_get_lock(conn, pool, path));
 
   /* Servers before 1.2 doesn't support locking.  Check this here. */
   SVN_ERR(handle_unsupported_cmd(handle_auth_request(sess, pool),
                                  N_("Server doesn't support the get-lock "
                                     "command")));
 
-  SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, "(?l)", &list));
+  SVN_ERR(svn_ra_svn__read_cmd_response(conn, pool, "(?l)", &list));
   if (list)
     SVN_ERR(parse_lock(list, pool, lock));
   else
@@ -2418,14 +2418,14 @@ static svn_error_t *ra_svn_get_locks(svn
   SVN_ERR(path_relative_to_root(session, &abs_path, full_url, pool));
   abs_path = svn_fspath__canonicalize(abs_path, pool);
 
-  SVN_ERR(svn_ra_svn_write_cmd_get_locks(conn, pool, path, depth));
+  SVN_ERR(svn_ra_svn__write_cmd_get_locks(conn, pool, path, depth));
 
   /* Servers before 1.2 doesn't support locking.  Check this here. */
   SVN_ERR(handle_unsupported_cmd(handle_auth_request(sess, pool),
                                  N_("Server doesn't support the get-lock "
                                     "command")));
 
-  SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, "l", &list));
+  SVN_ERR(svn_ra_svn__read_cmd_response(conn, pool, "l", &list));
 
   *locks = apr_hash_make(pool);
 
@@ -2475,8 +2475,8 @@ static svn_error_t *ra_svn_replay(svn_ra
 {
   svn_ra_svn__session_baton_t *sess = session->priv;
 
-  SVN_ERR(svn_ra_svn_write_cmd_replay(sess->conn, pool, revision,
-                                      low_water_mark, send_deltas));
+  SVN_ERR(svn_ra_svn__write_cmd_replay(sess->conn, pool, revision,
+                                       low_water_mark, send_deltas));
 
   SVN_ERR(handle_unsupported_cmd(handle_auth_request(sess, pool),
                                  N_("Server doesn't support the replay "
@@ -2485,7 +2485,7 @@ static svn_error_t *ra_svn_replay(svn_ra
   SVN_ERR(svn_ra_svn_drive_editor2(sess->conn, pool, editor, edit_baton,
                                    NULL, TRUE));
 
-  return svn_ra_svn_read_cmd_response(sess->conn, pool, "");
+  return svn_ra_svn__read_cmd_response(sess->conn, pool, "");
 }
 
 
@@ -2505,9 +2505,9 @@ ra_svn_replay_range(svn_ra_session_t *se
   svn_revnum_t rev;
   svn_boolean_t drive_aborted = FALSE;
 
-  SVN_ERR(svn_ra_svn_write_cmd_replay_range(sess->conn, pool,
-                                            start_revision, end_revision,
-                                            low_water_mark, send_deltas));
+  SVN_ERR(svn_ra_svn__write_cmd_replay_range(sess->conn, pool,
+                                             start_revision, end_revision,
+                                             low_water_mark, send_deltas));
 
   SVN_ERR(handle_unsupported_cmd(handle_auth_request(sess, pool),
                                  N_("Server doesn't support the "
@@ -2524,14 +2524,14 @@ ra_svn_replay_range(svn_ra_session_t *se
 
       svn_pool_clear(iterpool);
 
-      SVN_ERR(svn_ra_svn_read_tuple(sess->conn, iterpool,
-                                    "wl", &word, &list));
+      SVN_ERR(svn_ra_svn__read_tuple(sess->conn, iterpool,
+                                     "wl", &word, &list));
       if (strcmp(word, "revprops") != 0)
         return svn_error_createf(SVN_ERR_RA_SVN_MALFORMED_DATA, NULL,
                                  _("Expected 'revprops', found '%s'"),
                                  word);
 
-      SVN_ERR(svn_ra_svn_parse_proplist(list, iterpool, &rev_props));
+      SVN_ERR(svn_ra_svn__parse_proplist(list, iterpool, &rev_props));
 
       SVN_ERR(revstart_func(rev, replay_baton,
                             &editor, &edit_baton,
@@ -2554,7 +2554,7 @@ ra_svn_replay_range(svn_ra_session_t *se
     }
   svn_pool_destroy(iterpool);
 
-  return svn_ra_svn_read_cmd_response(sess->conn, pool, "");
+  return svn_ra_svn__read_cmd_response(sess->conn, pool, "");
 }
 
 
@@ -2613,14 +2613,14 @@ ra_svn_get_deleted_rev(svn_ra_session_t 
   svn_ra_svn_conn_t *conn = sess_baton->conn;
 
   /* Transmit the parameters. */
-  SVN_ERR(svn_ra_svn_write_cmd_get_deleted_rev(conn, pool, path,
+  SVN_ERR(svn_ra_svn__write_cmd_get_deleted_rev(conn, pool, path,
                                                peg_revision, end_revision));
 
   /* Servers before 1.6 don't support this command.  Check for this here. */
   SVN_ERR(handle_unsupported_cmd(handle_auth_request(sess_baton, pool),
                                  N_("'get-deleted-rev' not implemented")));
 
-  return svn_ra_svn_read_cmd_response(conn, pool, "r", revision_deleted);
+  return svn_ra_svn__read_cmd_response(conn, pool, "r", revision_deleted);
 }
 
 static svn_error_t *
@@ -2647,10 +2647,10 @@ ra_svn_get_inherited_props(svn_ra_sessio
   svn_ra_svn_conn_t *conn = sess_baton->conn;
   apr_array_header_t *iproplist;
 
-  SVN_ERR(svn_ra_svn_write_cmd_get_iprops(conn, scratch_pool,
-                                          path, revision));
+  SVN_ERR(svn_ra_svn__write_cmd_get_iprops(conn, scratch_pool,
+                                           path, revision));
   SVN_ERR(handle_auth_request(sess_baton, scratch_pool));
-  SVN_ERR(svn_ra_svn_read_cmd_response(conn, scratch_pool, "l", &iproplist));
+  SVN_ERR(svn_ra_svn__read_cmd_response(conn, scratch_pool, "l", &iproplist));
   SVN_ERR(parse_iproplist(iprops, iproplist, session, result_pool,
                           scratch_pool));
 

Modified: subversion/branches/verify-keep-going/subversion/libsvn_ra_svn/cram.c
URL: http://svn.apache.org/viewvc/subversion/branches/verify-keep-going/subversion/libsvn_ra_svn/cram.c?rev=1489765&r1=1489764&r2=1489765&view=diff
==============================================================================
--- subversion/branches/verify-keep-going/subversion/libsvn_ra_svn/cram.c (original)
+++ subversion/branches/verify-keep-going/subversion/libsvn_ra_svn/cram.c Wed Jun  5 09:22:43 2013
@@ -113,8 +113,8 @@ static void compute_digest(unsigned char
 static svn_error_t *fail(svn_ra_svn_conn_t *conn, apr_pool_t *pool,
                          const char *msg)
 {
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "w(c)", "failure", msg));
-  return svn_ra_svn_flush(conn, pool);
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "w(c)", "failure", msg));
+  return svn_ra_svn__flush(conn, pool);
 }
 
 /* If we can, make the nonce with random bytes.  If we can't... well,
@@ -154,10 +154,10 @@ svn_error_t *svn_ra_svn_cram_server(svn_
   challenge = apr_psprintf(pool,
                            "<%" APR_UINT64_T_FMT ".%" APR_TIME_T_FMT "@%s>",
                            nonce, apr_time_now(), hostbuf);
-  SVN_ERR(svn_ra_svn_write_tuple(conn, pool, "w(c)", "step", challenge));
+  SVN_ERR(svn_ra_svn__write_tuple(conn, pool, "w(c)", "step", challenge));
 
   /* Read the client's response and decode it into *user and cdigest. */
-  SVN_ERR(svn_ra_svn_read_item(conn, pool, &item));
+  SVN_ERR(svn_ra_svn__read_item(conn, pool, &item));
   if (item->kind != SVN_RA_SVN_STRING)  /* Very wrong; don't report failure */
     return SVN_NO_ERROR;
   resp = item->u.string;
@@ -176,7 +176,7 @@ svn_error_t *svn_ra_svn_cram_server(svn_
     return fail(conn, pool, "Password incorrect");
 
   *success = TRUE;
-  return svn_ra_svn_write_tuple(conn, pool, "w()", "success");
+  return svn_ra_svn__write_tuple(conn, pool, "w()", "success");
 }
 
 svn_error_t *svn_ra_svn__cram_client(svn_ra_svn_conn_t *conn, apr_pool_t *pool,
@@ -188,7 +188,7 @@ svn_error_t *svn_ra_svn__cram_client(svn
   char hex[2 * APR_MD5_DIGESTSIZE + 1];
 
   /* Read the server challenge. */
-  SVN_ERR(svn_ra_svn_read_tuple(conn, pool, "w(?c)", &status, &str));
+  SVN_ERR(svn_ra_svn__read_tuple(conn, pool, "w(?c)", &status, &str));
   if (strcmp(status, "failure") == 0 && str)
     {
       *message = str;
@@ -203,10 +203,10 @@ svn_error_t *svn_ra_svn__cram_client(svn
   hex_encode(hex, digest);
   hex[sizeof(hex) - 1] = '\0';
   reply = apr_psprintf(pool, "%s %s", user, hex);
-  SVN_ERR(svn_ra_svn_write_cstring(conn, pool, reply));
+  SVN_ERR(svn_ra_svn__write_cstring(conn, pool, reply));
 
   /* Read the success or failure response from the server. */
-  SVN_ERR(svn_ra_svn_read_tuple(conn, pool, "w(?c)", &status, &str));
+  SVN_ERR(svn_ra_svn__read_tuple(conn, pool, "w(?c)", &status, &str));
   if (strcmp(status, "failure") == 0 && str)
     {
       *message = str;

Modified: subversion/branches/verify-keep-going/subversion/libsvn_ra_svn/cyrus_auth.c
URL: http://svn.apache.org/viewvc/subversion/branches/verify-keep-going/subversion/libsvn_ra_svn/cyrus_auth.c?rev=1489765&r1=1489764&r2=1489765&view=diff
==============================================================================
--- subversion/branches/verify-keep-going/subversion/libsvn_ra_svn/cyrus_auth.c (original)
+++ subversion/branches/verify-keep-going/subversion/libsvn_ra_svn/cyrus_auth.c Wed Jun  5 09:22:43 2013
@@ -507,8 +507,8 @@ static svn_error_t *try_auth(svn_ra_svn_
   while (result == SASL_CONTINUE)
     {
       /* Read the server response */
-      SVN_ERR(svn_ra_svn_read_tuple(sess->conn, pool, "w(?s)",
-                                    &status, &in));
+      SVN_ERR(svn_ra_svn__read_tuple(sess->conn, pool, "w(?s)",
+                                     &status, &in));
 
       if (strcmp(status, "failure") == 0)
         {
@@ -553,18 +553,18 @@ static svn_error_t *try_auth(svn_ra_svn_
           /* For CRAM-MD5, we don't use base64-encoding. */
           if (strcmp(mech, "CRAM-MD5") != 0)
             arg = svn_base64_encode_string2(arg, TRUE, pool);
-          SVN_ERR(svn_ra_svn_write_cstring(sess->conn, pool, arg->data));
+          SVN_ERR(svn_ra_svn__write_cstring(sess->conn, pool, arg->data));
         }
       else
         {
-          SVN_ERR(svn_ra_svn_write_cstring(sess->conn, pool, ""));
+          SVN_ERR(svn_ra_svn__write_cstring(sess->conn, pool, ""));
         }
     }
 
   if (!status || strcmp(status, "step") == 0)
     {
       /* This is a client-send-last mech.  Read the last server response. */
-      SVN_ERR(svn_ra_svn_read_tuple(sess->conn, pool, "w(?s)",
+      SVN_ERR(svn_ra_svn__read_tuple(sess->conn, pool, "w(?s)",
               &status, &in));
 
       if (strcmp(status, "failure") == 0)
@@ -734,7 +734,7 @@ svn_error_t *svn_ra_svn__enable_sasl_enc
           const void *maxsize;
 
           /* Flush the connection, as we're about to replace its stream. */
-          SVN_ERR(svn_ra_svn_flush(conn, pool));
+          SVN_ERR(svn_ra_svn__flush(conn, pool));
 
           /* Create and initialize the stream baton. */
           sasl_baton = apr_pcalloc(conn->pool, sizeof(*sasl_baton));

Modified: subversion/branches/verify-keep-going/subversion/libsvn_ra_svn/editorp.c
URL: http://svn.apache.org/viewvc/subversion/branches/verify-keep-going/subversion/libsvn_ra_svn/editorp.c?rev=1489765&r1=1489764&r2=1489765&view=diff
==============================================================================
--- subversion/branches/verify-keep-going/subversion/libsvn_ra_svn/editorp.c (original)
+++ subversion/branches/verify-keep-going/subversion/libsvn_ra_svn/editorp.c Wed Jun  5 09:22:43 2013
@@ -138,8 +138,8 @@ check_for_error_internal(ra_svn_edit_bat
   if (svn_ra_svn__input_waiting(eb->conn, pool))
     {
       eb->got_status = TRUE;
-      SVN_ERR(svn_ra_svn_write_cmd_abort_edit(eb->conn, pool));
-      SVN_ERR(svn_ra_svn_read_cmd_response(eb->conn, pool, ""));
+      SVN_ERR(svn_ra_svn__write_cmd_abort_edit(eb->conn, pool));
+      SVN_ERR(svn_ra_svn__read_cmd_response(eb->conn, pool, ""));
       /* We shouldn't get here if the consumer is doing its job. */
       return svn_error_create(SVN_ERR_RA_SVN_MALFORMED_DATA, NULL,
                               _("Successful edit status returned too soon"));
@@ -161,7 +161,7 @@ static svn_error_t *ra_svn_target_rev(vo
   ra_svn_edit_baton_t *eb = edit_baton;
 
   SVN_ERR(check_for_error(eb, pool));
-  SVN_ERR(svn_ra_svn_write_cmd_target_rev(eb->conn, pool, rev));
+  SVN_ERR(svn_ra_svn__write_cmd_target_rev(eb->conn, pool, rev));
   return SVN_NO_ERROR;
 }
 
@@ -172,7 +172,7 @@ static svn_error_t *ra_svn_open_root(voi
   const char *token = make_token('d', eb, pool);
 
   SVN_ERR(check_for_error(eb, pool));
-  SVN_ERR(svn_ra_svn_write_cmd_open_root(eb->conn, pool, rev, token));
+  SVN_ERR(svn_ra_svn__write_cmd_open_root(eb->conn, pool, rev, token));
   *root_baton = ra_svn_make_baton(eb->conn, pool, eb, token);
   return SVN_NO_ERROR;
 }
@@ -183,8 +183,8 @@ static svn_error_t *ra_svn_delete_entry(
   ra_svn_baton_t *b = parent_baton;
 
   SVN_ERR(check_for_error(b->eb, pool));
-  SVN_ERR(svn_ra_svn_write_cmd_delete_entry(b->conn, pool,
-                                            path, rev, b->token));
+  SVN_ERR(svn_ra_svn__write_cmd_delete_entry(b->conn, pool,
+                                             path, rev, b->token));
   return SVN_NO_ERROR;
 }
 
@@ -199,8 +199,8 @@ static svn_error_t *ra_svn_add_dir(const
   SVN_ERR_ASSERT((copy_path && SVN_IS_VALID_REVNUM(copy_rev))
                  || (!copy_path && !SVN_IS_VALID_REVNUM(copy_rev)));
   SVN_ERR(check_for_error(b->eb, pool));
-  SVN_ERR(svn_ra_svn_write_cmd_add_dir(b->conn, pool, path, b->token,
-                                       token, copy_path, copy_rev));
+  SVN_ERR(svn_ra_svn__write_cmd_add_dir(b->conn, pool, path, b->token,
+                                        token, copy_path, copy_rev));
   *child_baton = ra_svn_make_baton(b->conn, pool, b->eb, token);
   return SVN_NO_ERROR;
 }
@@ -213,8 +213,8 @@ static svn_error_t *ra_svn_open_dir(cons
   const char *token = make_token('d', b->eb, pool);
 
   SVN_ERR(check_for_error(b->eb, pool));
-  SVN_ERR(svn_ra_svn_write_cmd_open_dir(b->conn, pool, path, b->token,
-                                        token, rev));
+  SVN_ERR(svn_ra_svn__write_cmd_open_dir(b->conn, pool, path, b->token,
+                                         token, rev));
   *child_baton = ra_svn_make_baton(b->conn, pool, b->eb, token);
   return SVN_NO_ERROR;
 }
@@ -226,8 +226,8 @@ static svn_error_t *ra_svn_change_dir_pr
   ra_svn_baton_t *b = dir_baton;
 
   SVN_ERR(check_for_error(b->eb, pool));
-  SVN_ERR(svn_ra_svn_write_cmd_change_dir_prop(b->conn, pool, b->token,
-                                               name, value));
+  SVN_ERR(svn_ra_svn__write_cmd_change_dir_prop(b->conn, pool, b->token,
+                                                name, value));
   return SVN_NO_ERROR;
 }
 
@@ -236,7 +236,7 @@ static svn_error_t *ra_svn_close_dir(voi
   ra_svn_baton_t *b = dir_baton;
 
   SVN_ERR(check_for_error(b->eb, pool));
-  SVN_ERR(svn_ra_svn_write_cmd_close_dir(b->conn, pool, b->token));
+  SVN_ERR(svn_ra_svn__write_cmd_close_dir(b->conn, pool, b->token));
   return SVN_NO_ERROR;
 }
 
@@ -251,7 +251,7 @@ static svn_error_t *ra_svn_absent_dir(co
     return SVN_NO_ERROR;
 
   SVN_ERR(check_for_error(b->eb, pool));
-  SVN_ERR(svn_ra_svn_write_cmd_absent_dir(b->conn, pool, path, b->token));
+  SVN_ERR(svn_ra_svn__write_cmd_absent_dir(b->conn, pool, path, b->token));
   return SVN_NO_ERROR;
 }
 
@@ -268,8 +268,8 @@ static svn_error_t *ra_svn_add_file(cons
   SVN_ERR_ASSERT((copy_path && SVN_IS_VALID_REVNUM(copy_rev))
                  || (!copy_path && !SVN_IS_VALID_REVNUM(copy_rev)));
   SVN_ERR(check_for_error(b->eb, pool));
-  SVN_ERR(svn_ra_svn_write_cmd_add_file(b->conn, pool,  path, b->token,
-                                        token, copy_path, copy_rev));
+  SVN_ERR(svn_ra_svn__write_cmd_add_file(b->conn, pool,  path, b->token,
+                                         token, copy_path, copy_rev));
   *file_baton = ra_svn_make_baton(b->conn, pool, b->eb, token);
   return SVN_NO_ERROR;
 }
@@ -284,8 +284,8 @@ static svn_error_t *ra_svn_open_file(con
   const char *token = make_token('c', b->eb, pool);
 
   SVN_ERR(check_for_error(b->eb, b->pool));
-  SVN_ERR(svn_ra_svn_write_cmd_open_file(b->conn, pool, path, b->token,
-                                         token, rev));
+  SVN_ERR(svn_ra_svn__write_cmd_open_file(b->conn, pool, path, b->token,
+                                          token, rev));
   *file_baton = ra_svn_make_baton(b->conn, pool, b->eb, token);
   return SVN_NO_ERROR;
 }
@@ -299,8 +299,8 @@ static svn_error_t *ra_svn_svndiff_handl
   SVN_ERR(check_for_error(b->eb, b->pool));
   str.data = data;
   str.len = *len;
-  return svn_ra_svn_write_cmd_textdelta_chunk(b->conn, b->pool,
-                                              b->token, &str);
+  return svn_ra_svn__write_cmd_textdelta_chunk(b->conn, b->pool,
+                                               b->token, &str);
 }
 
 static svn_error_t *ra_svn_svndiff_close_handler(void *baton)
@@ -308,7 +308,7 @@ static svn_error_t *ra_svn_svndiff_close
   ra_svn_baton_t *b = baton;
 
   SVN_ERR(check_for_error(b->eb, b->pool));
-  SVN_ERR(svn_ra_svn_write_cmd_textdelta_end(b->conn, b->pool, b->token));
+  SVN_ERR(svn_ra_svn__write_cmd_textdelta_end(b->conn, b->pool, b->token));
   return SVN_NO_ERROR;
 }
 
@@ -323,8 +323,8 @@ static svn_error_t *ra_svn_apply_textdel
 
   /* Tell the other side we're starting a text delta. */
   SVN_ERR(check_for_error(b->eb, pool));
-  SVN_ERR(svn_ra_svn_write_cmd_apply_textdelta(b->conn, pool, b->token,
-                                               base_checksum));
+  SVN_ERR(svn_ra_svn__write_cmd_apply_textdelta(b->conn, pool, b->token,
+                                                base_checksum));
 
   /* Transform the window stream to an svndiff stream.  Reuse the
    * file baton for the stream handler, since it has all the
@@ -353,8 +353,8 @@ static svn_error_t *ra_svn_change_file_p
   ra_svn_baton_t *b = file_baton;
 
   SVN_ERR(check_for_error(b->eb, pool));
-  SVN_ERR(svn_ra_svn_write_cmd_change_file_prop(b->conn, pool,
-                                                b->token, name, value));
+  SVN_ERR(svn_ra_svn__write_cmd_change_file_prop(b->conn, pool,
+                                                 b->token, name, value));
   return SVN_NO_ERROR;
 }
 
@@ -365,8 +365,8 @@ static svn_error_t *ra_svn_close_file(vo
   ra_svn_baton_t *b = file_baton;
 
   SVN_ERR(check_for_error(b->eb, pool));
-  SVN_ERR(svn_ra_svn_write_cmd_close_file(b->conn, pool,
-                                          b->token, text_checksum));
+  SVN_ERR(svn_ra_svn__write_cmd_close_file(b->conn, pool,
+                                           b->token, text_checksum));
   return SVN_NO_ERROR;
 }
 
@@ -381,7 +381,7 @@ static svn_error_t *ra_svn_absent_file(c
     return SVN_NO_ERROR;
 
   SVN_ERR(check_for_error(b->eb, pool));
-  SVN_ERR(svn_ra_svn_write_cmd_absent_file(b->conn, pool, path, b->token));
+  SVN_ERR(svn_ra_svn__write_cmd_absent_file(b->conn, pool, path, b->token));
   return SVN_NO_ERROR;
 }
 
@@ -392,11 +392,11 @@ static svn_error_t *ra_svn_close_edit(vo
 
   SVN_ERR_ASSERT(!eb->got_status);
   eb->got_status = TRUE;
-  SVN_ERR(svn_ra_svn_write_cmd_close_edit(eb->conn, pool));
-  err = svn_ra_svn_read_cmd_response(eb->conn, pool, "");
+  SVN_ERR(svn_ra_svn__write_cmd_close_edit(eb->conn, pool));
+  err = svn_ra_svn__read_cmd_response(eb->conn, pool, "");
   if (err)
     {
-      svn_error_clear(svn_ra_svn_write_cmd_abort_edit(eb->conn, pool));
+      svn_error_clear(svn_ra_svn__write_cmd_abort_edit(eb->conn, pool));
       return err;
     }
   if (eb->callback)
@@ -410,8 +410,8 @@ static svn_error_t *ra_svn_abort_edit(vo
 
   if (eb->got_status)
     return SVN_NO_ERROR;
-  SVN_ERR(svn_ra_svn_write_cmd_abort_edit(eb->conn, pool));
-  SVN_ERR(svn_ra_svn_read_cmd_response(eb->conn, pool, ""));
+  SVN_ERR(svn_ra_svn__write_cmd_abort_edit(eb->conn, pool));
+  SVN_ERR(svn_ra_svn__read_cmd_response(eb->conn, pool, ""));
   return SVN_NO_ERROR;
 }
 
@@ -495,7 +495,7 @@ static svn_error_t *ra_svn_handle_target
 {
   svn_revnum_t rev;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "r", &rev));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "r", &rev));
   SVN_CMD_ERR(ds->editor->set_target_revision(ds->edit_baton, rev, pool));
   return SVN_NO_ERROR;
 }
@@ -510,7 +510,7 @@ static svn_error_t *ra_svn_handle_open_r
   const char *token;
   void *root_baton;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "(?r)c", &rev, &token));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "(?r)c", &rev, &token));
   subpool = svn_pool_create(ds->pool);
   SVN_CMD_ERR(ds->editor->open_root(ds->edit_baton, rev, subpool,
                                     &root_baton));
@@ -527,7 +527,8 @@ static svn_error_t *ra_svn_handle_delete
   svn_revnum_t rev;
   ra_svn_token_entry_t *entry;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "c(?r)c", &path, &rev, &token));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "c(?r)c",
+                                  &path, &rev, &token));
   SVN_ERR(lookup_token(ds, token, FALSE, &entry));
   path = svn_relpath_canonicalize(path, pool);
   SVN_CMD_ERR(ds->editor->delete_entry(path, rev, entry->baton, pool));
@@ -545,8 +546,8 @@ static svn_error_t *ra_svn_handle_add_di
   apr_pool_t *subpool;
   void *child_baton;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "ccc(?cr)", &path, &token,
-                                 &child_token, &copy_path, &copy_rev));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "ccc(?cr)", &path, &token,
+                                  &child_token, &copy_path, &copy_rev));
   SVN_ERR(lookup_token(ds, token, FALSE, &entry));
   subpool = svn_pool_create(entry->pool);
   path = svn_relpath_canonicalize(path, pool);
@@ -578,8 +579,8 @@ static svn_error_t *ra_svn_handle_open_d
   apr_pool_t *subpool;
   void *child_baton;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "ccc(?r)", &path, &token,
-                                 &child_token, &rev));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "ccc(?r)", &path, &token,
+                                  &child_token, &rev));
   SVN_ERR(lookup_token(ds, token, FALSE, &entry));
   subpool = svn_pool_create(entry->pool);
   path = svn_relpath_canonicalize(path, pool);
@@ -598,8 +599,8 @@ static svn_error_t *ra_svn_handle_change
   svn_string_t *value;
   ra_svn_token_entry_t *entry;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "cc(?s)", &token, &name,
-                                 &value));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "cc(?s)", &token, &name,
+                                  &value));
   SVN_ERR(lookup_token(ds, token, FALSE, &entry));
   SVN_CMD_ERR(ds->editor->change_dir_prop(entry->baton, name, value,
                                           entry->pool));
@@ -615,7 +616,7 @@ static svn_error_t *ra_svn_handle_close_
   ra_svn_token_entry_t *entry;
 
   /* Parse and look up the directory token. */
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "c", &token));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "c", &token));
   SVN_ERR(lookup_token(ds, token, FALSE, &entry));
 
   /* Close the directory and destroy the baton. */
@@ -635,7 +636,7 @@ static svn_error_t *ra_svn_handle_absent
   ra_svn_token_entry_t *entry;
 
   /* Parse parameters and look up the directory token. */
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "cc", &path, &token));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "cc", &path, &token));
   SVN_ERR(lookup_token(ds, token, FALSE, &entry));
 
   /* Call the editor. */
@@ -652,8 +653,8 @@ static svn_error_t *ra_svn_handle_add_fi
   svn_revnum_t copy_rev;
   ra_svn_token_entry_t *entry, *file_entry;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "ccc(?cr)", &path, &token,
-                                 &file_token, &copy_path, &copy_rev));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "ccc(?cr)", &path, &token,
+                                  &file_token, &copy_path, &copy_rev));
   SVN_ERR(lookup_token(ds, token, FALSE, &entry));
   ds->file_refs++;
   path = svn_relpath_canonicalize(path, pool);
@@ -683,8 +684,8 @@ static svn_error_t *ra_svn_handle_open_f
   svn_revnum_t rev;
   ra_svn_token_entry_t *entry, *file_entry;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "ccc(?r)", &path, &token,
-                                 &file_token, &rev));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "ccc(?r)", &path, &token,
+                                  &file_token, &rev));
   SVN_ERR(lookup_token(ds, token, FALSE, &entry));
   ds->file_refs++;
   path = svn_relpath_canonicalize(path, pool);
@@ -706,8 +707,8 @@ static svn_error_t *ra_svn_handle_apply_
   char *base_checksum;
 
   /* Parse arguments and look up the token. */
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "c(?c)",
-                                 &token, &base_checksum));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "c(?c)",
+                                  &token, &base_checksum));
   SVN_ERR(lookup_token(ds, token, TRUE, &entry));
   if (entry->dstream)
     return svn_error_create(SVN_ERR_RA_SVN_MALFORMED_DATA, NULL,
@@ -729,7 +730,7 @@ static svn_error_t *ra_svn_handle_textde
   svn_string_t *str;
 
   /* Parse arguments and look up the token. */
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "cs", &token, &str));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "cs", &token, &str));
   SVN_ERR(lookup_token(ds, token, TRUE, &entry));
   if (!entry->dstream)
     return svn_error_create(SVN_ERR_RA_SVN_MALFORMED_DATA, NULL,
@@ -747,7 +748,7 @@ static svn_error_t *ra_svn_handle_textde
   ra_svn_token_entry_t *entry;
 
   /* Parse arguments and look up the token. */
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "c", &token));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "c", &token));
   SVN_ERR(lookup_token(ds, token, TRUE, &entry));
   if (!entry->dstream)
     return svn_error_create(SVN_ERR_RA_SVN_MALFORMED_DATA, NULL,
@@ -767,8 +768,8 @@ static svn_error_t *ra_svn_handle_change
   svn_string_t *value;
   ra_svn_token_entry_t *entry;
 
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "cc(?s)", &token, &name,
-                                 &value));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "cc(?s)", &token, &name,
+                                  &value));
   SVN_ERR(lookup_token(ds, token, TRUE, &entry));
   SVN_CMD_ERR(ds->editor->change_file_prop(entry->baton, name, value, pool));
   return SVN_NO_ERROR;
@@ -784,8 +785,8 @@ static svn_error_t *ra_svn_handle_close_
   const char *text_checksum;
 
   /* Parse arguments and look up the file token. */
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "c(?c)",
-                                 &token, &text_checksum));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "c(?c)",
+                                  &token, &text_checksum));
   SVN_ERR(lookup_token(ds, token, TRUE, &entry));
 
   /* Close the file and destroy the baton. */
@@ -806,7 +807,7 @@ static svn_error_t *ra_svn_handle_absent
   ra_svn_token_entry_t *entry;
 
   /* Parse parameters and look up the parent directory token. */
-  SVN_ERR(svn_ra_svn_parse_tuple(params, pool, "cc", &path, &token));
+  SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "cc", &path, &token));
   SVN_ERR(lookup_token(ds, token, FALSE, &entry));
 
   /* Call the editor. */
@@ -823,7 +824,7 @@ static svn_error_t *ra_svn_handle_close_
   ds->done = TRUE;
   if (ds->aborted)
     *ds->aborted = FALSE;
-  return svn_ra_svn_write_cmd_response(conn, pool, "");
+  return svn_ra_svn__write_cmd_response(conn, pool, "");
 }
 
 static svn_error_t *ra_svn_handle_abort_edit(svn_ra_svn_conn_t *conn,
@@ -835,7 +836,7 @@ static svn_error_t *ra_svn_handle_abort_
   if (ds->aborted)
     *ds->aborted = TRUE;
   SVN_CMD_ERR(ds->editor->abort_edit(ds->edit_baton, pool));
-  return svn_ra_svn_write_cmd_response(conn, pool, "");
+  return svn_ra_svn__write_cmd_response(conn, pool, "");
 }
 
 static svn_error_t *ra_svn_handle_finish_replay(svn_ra_svn_conn_t *conn,
@@ -890,7 +891,7 @@ static svn_error_t *blocked_write(svn_ra
 
   /* We blocked trying to send an error.  Read and discard an editing
    * command in order to avoid deadlock. */
-  SVN_ERR(svn_ra_svn_read_tuple(conn, pool, "wl", &cmd, &params));
+  SVN_ERR(svn_ra_svn__read_tuple(conn, pool, "wl", &cmd, &params));
   if (strcmp(cmd, "abort-edit") == 0)
     {
       ds->done = TRUE;
@@ -928,7 +929,7 @@ svn_error_t *svn_ra_svn_drive_editor2(sv
       svn_pool_clear(subpool);
       if (editor)
         {
-          SVN_ERR(svn_ra_svn_read_tuple(conn, subpool, "wl", &cmd, &params));
+          SVN_ERR(svn_ra_svn__read_tuple(conn, subpool, "wl", &cmd, &params));
           for (i = 0; ra_svn_edit_cmds[i].cmd; i++)
               if (strcmp(cmd, ra_svn_edit_cmds[i].cmd) == 0)
                 break;
@@ -963,7 +964,7 @@ svn_error_t *svn_ra_svn_drive_editor2(sv
               state.done = TRUE;
               if (aborted)
                 *aborted = FALSE;
-              err = svn_ra_svn_write_cmd_response(conn, pool, "");
+              err = svn_ra_svn__write_cmd_response(conn, pool, "");
             }
           else
             err = NULL;
@@ -980,11 +981,11 @@ svn_error_t *svn_ra_svn_drive_editor2(sv
                 svn_error_clear(editor->abort_edit(edit_baton, subpool));
               svn_ra_svn__set_block_handler(conn, blocked_write, &state);
             }
-          write_err = svn_ra_svn_write_cmd_failure(
+          write_err = svn_ra_svn__write_cmd_failure(
                           conn, subpool,
                           svn_ra_svn__locate_real_error_child(err));
           if (!write_err)
-            write_err = svn_ra_svn_flush(conn, subpool);
+            write_err = svn_ra_svn__flush(conn, subpool);
           svn_ra_svn__set_block_handler(conn, NULL, NULL);
           svn_error_clear(err);
           SVN_ERR(write_err);
@@ -1011,7 +1012,7 @@ svn_error_t *svn_ra_svn_drive_editor2(sv
   while (!state.done)
     {
       svn_pool_clear(subpool);
-      err = svn_ra_svn_read_tuple(conn, subpool, "wl", &cmd, &params);
+      err = svn_ra_svn__read_tuple(conn, subpool, "wl", &cmd, &params);
       if (err && err->apr_err == SVN_ERR_RA_SVN_CONNECTION_CLOSED)
         {
           /* Other side disconnected; that's no error. */

Modified: subversion/branches/verify-keep-going/subversion/libsvn_ra_svn/internal_auth.c
URL: http://svn.apache.org/viewvc/subversion/branches/verify-keep-going/subversion/libsvn_ra_svn/internal_auth.c?rev=1489765&r1=1489764&r2=1489765&view=diff
==============================================================================
--- subversion/branches/verify-keep-going/subversion/libsvn_ra_svn/internal_auth.c (original)
+++ subversion/branches/verify-keep-going/subversion/libsvn_ra_svn/internal_auth.c Wed Jun  5 09:22:43 2013
@@ -57,7 +57,7 @@ static svn_error_t *read_success(svn_ra_
 {
   const char *status, *arg;
 
-  SVN_ERR(svn_ra_svn_read_tuple(conn, pool, "w(?c)", &status, &arg));
+  SVN_ERR(svn_ra_svn__read_tuple(conn, pool, "w(?c)", &status, &arg));
   if (strcmp(status, "failure") == 0 && arg)
     return svn_error_createf(SVN_ERR_RA_NOT_AUTHORIZED, NULL,
                              _("Authentication error from server: %s"), arg);



Mime
View raw message