contrib/subversion/subversion/libsvn_ra_svn/deprecated.c

   1 /*
   2  * deprecated.c :  Public, deprecated wrappers to our private ra_svn API
   3  *
   4  * ====================================================================
   5  *    Licensed to the Apache Software Foundation (ASF) under one
   6  *    or more contributor license agreements.  See the NOTICE file
   7  *    distributed with this work for additional information
   8  *    regarding copyright ownership.  The ASF licenses this file
   9  *    to you under the Apache License, Version 2.0 (the
  10  *    "License"); you may not use this file except in compliance
  11  *    with the License.  You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  *    Unless required by applicable law or agreed to in writing,
  16  *    software distributed under the License is distributed on an
  17  *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  18  *    KIND, either express or implied.  See the License for the
  19  *    specific language governing permissions and limitations
  20  *    under the License.
  21  * ====================================================================
  22  */
  23
  24 /* We define this here to remove any further warnings about the usage of
  25    deprecated functions in this file. */
  26 #define SVN_DEPRECATED
  27
  28 #include "svn_ra_svn.h"
  29
  30 #include "private/svn_ra_svn_private.h"
  31
  32 svn_error_t *
  33 svn_ra_svn_write_number(svn_ra_svn_conn_t *conn,
  34                         apr_pool_t *pool,
  35                         apr_uint64_t number)
  36 {
  37   return svn_error_trace(svn_ra_svn__write_number(conn, pool, number));
  38 }
  39
  40 svn_error_t *
  41 svn_ra_svn_write_string(svn_ra_svn_conn_t *conn,
  42                         apr_pool_t *pool,
  43                         const svn_string_t *str)
  44 {
  45   return svn_error_trace(svn_ra_svn__write_string(conn, pool, str));
  46 }
  47
  48 svn_error_t *
  49 svn_ra_svn_write_cstring(svn_ra_svn_conn_t *conn,
  50                          apr_pool_t *pool,
  51                          const char *s)
  52 {
  53   return svn_error_trace(svn_ra_svn__write_cstring(conn, pool, s));
  54 }
  55
  56 svn_error_t *
  57 svn_ra_svn_write_word(svn_ra_svn_conn_t *conn,
  58                       apr_pool_t *pool,
  59                       const char *word)
  60 {
  61   return svn_error_trace(svn_ra_svn__write_word(conn, pool, word));
  62 }
  63
  64 svn_error_t *
  65 svn_ra_svn_write_proplist(svn_ra_svn_conn_t *conn,
  66                           apr_pool_t *pool,
  67                           apr_hash_t *props)
  68 {
  69   return svn_error_trace(svn_ra_svn__write_proplist(conn, pool, props));
  70 }
  71
  72 svn_error_t *
  73 svn_ra_svn_start_list(svn_ra_svn_conn_t *conn,
  74                       apr_pool_t *pool)
  75 {
  76   return svn_error_trace(svn_ra_svn__start_list(conn, pool));
  77 }
  78
  79 svn_error_t *
  80 svn_ra_svn_end_list(svn_ra_svn_conn_t *conn,
  81                     apr_pool_t *pool)
  82 {
  83   return svn_error_trace(svn_ra_svn__end_list(conn, pool));
  84 }
  85
  86 svn_error_t *
  87 svn_ra_svn_flush(svn_ra_svn_conn_t *conn,
  88                  apr_pool_t *pool)
  89 {
  90   return svn_error_trace(svn_ra_svn__flush(conn, pool));
  91 }
  92
  93 svn_error_t *
  94 svn_ra_svn_write_tuple(svn_ra_svn_conn_t *conn,
  95                        apr_pool_t *pool,
  96                        const char *fmt, ...)
  97 {
  98   va_list va;
  99   svn_error_t *err;
 100
 101   va_start(va, fmt);
 102   err = svn_ra_svn__write_tuple(conn, pool, fmt, va);
 103   va_end(va);
 104
 105   return svn_error_trace(err);
 106 }
 107
 108 svn_error_t *
 109 svn_ra_svn_read_item(svn_ra_svn_conn_t *conn,
 110                      apr_pool_t *pool,
 111                      svn_ra_svn_item_t **item)
 112 {
 113   svn_ra_svn__item_t *temp;
 114   SVN_ERR(svn_ra_svn__read_item(conn, pool, &temp));
 115   *item  = apr_pcalloc(pool, sizeof(**item));
 116   svn_ra_svn__to_public_item(*item, temp, pool);
 117
 118   return SVN_NO_ERROR;
 119 }
 120
 121 svn_error_t *
 122 svn_ra_svn_skip_leading_garbage(svn_ra_svn_conn_t *conn,
 123                                 apr_pool_t *pool)
 124 {
 125   return svn_error_trace(svn_ra_svn__skip_leading_garbage(conn, pool));
 126 }
 127
 128 svn_error_t *
 129 svn_ra_svn_parse_tuple(const apr_array_header_t *list,
 130                        apr_pool_t *pool,
 131                        const char *fmt, ...)
 132 {
 133   va_list va;
 134   svn_error_t *err;
 135   svn_ra_svn__list_t *internal = svn_ra_svn__to_private_array(list, pool);
 136
 137   va_start(va, fmt);
 138   err = svn_ra_svn__parse_tuple(internal, fmt, va);
 139   va_end(va);
 140
 141   return svn_error_trace(err);
 142 }
 143
 144 svn_error_t *
 145 svn_ra_svn_read_tuple(svn_ra_svn_conn_t *conn,
 146                       apr_pool_t *pool,
 147                       const char *fmt, ...)
 148 {
 149   va_list va;
 150   svn_error_t *err;
 151
 152   va_start(va, fmt);
 153   err = svn_ra_svn__read_tuple(conn, pool, fmt, va);
 154   va_end(va);
 155
 156   return svn_error_trace(err);
 157 }
 158
 159 svn_error_t *
 160 svn_ra_svn_parse_proplist(const apr_array_header_t *list,
 161                           apr_pool_t *pool,
 162                           apr_hash_t **props)
 163 {
 164   svn_ra_svn__list_t *internal
 165     = svn_ra_svn__to_private_array(list, pool);
 166   return svn_error_trace(svn_ra_svn__parse_proplist(internal, pool, props));
 167 }
 168
 169 svn_error_t *
 170 svn_ra_svn_read_cmd_response(svn_ra_svn_conn_t *conn,
 171                              apr_pool_t *pool,
 172                              const char *fmt, ...)
 173 {
 174   va_list va;
 175   svn_error_t *err;
 176
 177   va_start(va, fmt);
 178   err = svn_ra_svn__read_cmd_response(conn, pool, fmt, va);
 179   va_end(va);
 180
 181   return svn_error_trace(err);
 182 }
 183
 184 svn_error_t *
 185 svn_ra_svn_handle_commands2(svn_ra_svn_conn_t *conn,
 186                             apr_pool_t *pool,
 187                             const svn_ra_svn_cmd_entry_t *commands,
 188                             void *baton,
 189                             svn_boolean_t error_on_disconnect)
 190 {
 191   apr_size_t i, count = 0;
 192   svn_ra_svn__cmd_entry_t *internal;
 193
 194   while (commands[count].cmdname)
 195     count++;
 196
 197   internal = apr_pcalloc(pool, count * sizeof(*internal));
 198   for (i = 0; i < count; ++i)
 199     {
 200       internal[i].cmdname = commands[i].cmdname;
 201       internal[i].handler = NULL;
 202       internal[i].deprecated_handler = commands[i].handler;
 203       internal[i].terminate = commands[i].terminate;
 204     }
 205
 206   return svn_error_trace(svn_ra_svn__handle_commands2(conn, pool,
 207                                                       internal, baton,
 208                                                       error_on_disconnect));
 209 }
 210
 211 svn_error_t *
 212 svn_ra_svn_handle_commands(svn_ra_svn_conn_t *conn,
 213                            apr_pool_t *pool,
 214                            const svn_ra_svn_cmd_entry_t *commands,
 215                            void *baton)
 216 {
 217   return svn_error_trace(svn_ra_svn_handle_commands2(conn, pool,
 218                                                      commands, baton,
 219                                                      FALSE));
 220 }
 221
 222 svn_error_t *
 223 svn_ra_svn_write_cmd(svn_ra_svn_conn_t *conn,
 224                      apr_pool_t *pool,
 225                      const char *cmdname,
 226                      const char *fmt, ...)
 227 {
 228   va_list va;
 229   svn_error_t *err;
 230
 231   SVN_ERR(svn_ra_svn__start_list(conn, pool));
 232   SVN_ERR(svn_ra_svn__write_word(conn, pool, cmdname));
 233   va_start(va, fmt);
 234   err = svn_ra_svn__write_tuple(conn, pool, fmt, va);
 235   va_end(va);
 236   return err ? svn_error_trace(err) : svn_ra_svn__end_list(conn, pool);
 237 }
 238
 239 svn_error_t *
 240 svn_ra_svn_write_cmd_response(svn_ra_svn_conn_t *conn,
 241                               apr_pool_t *pool,
 242                               const char *fmt, ...)
 243 {
 244   va_list va;
 245   svn_error_t *err;
 246
 247   va_start(va, fmt);
 248   err = svn_ra_svn__write_cmd_response(conn, pool, fmt, va);
 249   va_end(va);
 250
 251   return svn_error_trace(err);
 252 }
 253
 254
 255 svn_error_t *
 256 svn_ra_svn_write_cmd_failure(svn_ra_svn_conn_t *conn,
 257                              apr_pool_t *pool,
 258                              svn_error_t *err)
 259 {
 260   return svn_error_trace(svn_ra_svn__write_cmd_failure(conn, pool, err));
 261 }
 262
 263 /* From marshal.c */
 264 svn_ra_svn_conn_t *
 265 svn_ra_svn_create_conn4(apr_socket_t *sock,
 266                         svn_stream_t *in_stream,
 267                         svn_stream_t *out_stream,
 268                         int compression_level,
 269                         apr_size_t zero_copy_limit,
 270                         apr_size_t error_check_interval,
 271                         apr_pool_t *pool)
 272 {
 273   return svn_ra_svn_create_conn5(sock, in_stream, out_stream,
 274                                  compression_level, zero_copy_limit,
 275                                  error_check_interval, 0, 0, pool);
 276 }
 277
 278 svn_ra_svn_conn_t *
 279 svn_ra_svn_create_conn3(apr_socket_t *sock,
 280                         apr_file_t *in_file,
 281                         apr_file_t *out_file,
 282                         int compression_level,
 283                         apr_size_t zero_copy_limit,
 284                         apr_size_t error_check_interval,
 285                         apr_pool_t *pool)
 286 {
 287   svn_stream_t *in_stream = NULL;
 288   svn_stream_t *out_stream = NULL;
 289
 290   if (in_file)
 291     in_stream = svn_stream_from_aprfile2(in_file, FALSE, pool);
 292   if (out_file)
 293     out_stream = svn_stream_from_aprfile2(out_file, FALSE, pool);
 294
 295   return svn_ra_svn_create_conn4(sock, in_stream, out_stream,
 296                                  compression_level, zero_copy_limit,
 297                                  error_check_interval, pool);
 298 }
 299
 300 svn_ra_svn_conn_t *
 301 svn_ra_svn_create_conn2(apr_socket_t *sock,
 302                         apr_file_t *in_file,
 303                         apr_file_t *out_file,
 304                         int compression_level,
 305                         apr_pool_t *pool)
 306 {
 307   return svn_ra_svn_create_conn3(sock, in_file, out_file,
 308                                  compression_level, 0, 0, pool);
 309 }
 310
 311 /* backward-compatible implementation using the default compression level */
 312 svn_ra_svn_conn_t *
 313 svn_ra_svn_create_conn(apr_socket_t *sock,
 314                        apr_file_t *in_file,
 315                        apr_file_t *out_file,
 316                        apr_pool_t *pool)
 317 {
 318   return svn_ra_svn_create_conn3(sock, in_file, out_file,
 319                                  SVN_DELTA_COMPRESSION_LEVEL_DEFAULT, 0, 0,
 320                                  pool);
 321 }