contrib/subversion/subversion/libsvn_ra_svn/ra_svn.h

   1 /*
   2  * ra_svn.h :  private declarations for the ra_svn module
   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
  25 \f
  26 #ifndef RA_SVN_H
  27 #define RA_SVN_H
  28
  29 #ifdef __cplusplus
  30 extern "C" {
  31 #endif /* __cplusplus */
  32
  33 #include <apr_network_io.h>
  34 #include <apr_file_io.h>
  35 #include <apr_thread_proc.h>
  36 #include "svn_ra.h"
  37 #include "svn_ra_svn.h"
  38
  39 #include "private/svn_ra_svn_private.h"
  40
  41 /* Callback function that indicates if a svn_ra_svn__stream_t has pending
  42  * data.
  43  */
  44 typedef svn_boolean_t (*ra_svn_pending_fn_t)(void *baton);
  45
  46 /* Callback function that sets the timeout value for a svn_ra_svn__stream_t. */
  47 typedef void (*ra_svn_timeout_fn_t)(void *baton, apr_interval_time_t timeout);
  48
  49 /* A stream abstraction for ra_svn.
  50  *
  51  * This is different from svn_stream_t in that it provides timeouts and
  52  * the ability to check for pending data.
  53  */
  54 typedef struct svn_ra_svn__stream_st svn_ra_svn__stream_t;
  55
  56 /* Handler for blocked writes. */
  57 typedef svn_error_t *(*ra_svn_block_handler_t)(svn_ra_svn_conn_t *conn,
  58                                                apr_pool_t *pool,
  59                                                void *baton);
  60
  61 /* The default "user agent". */
  62 #define SVN_RA_SVN__DEFAULT_USERAGENT  "SVN/" SVN_VER_NUMBER\
  63                                        " (" SVN_BUILD_TARGET ")"
  64
  65 /* The size of our per-connection read and write buffers. */
  66 #define SVN_RA_SVN__PAGE_SIZE 4096
  67 #define SVN_RA_SVN__READBUF_SIZE (4 * SVN_RA_SVN__PAGE_SIZE)
  68 #define SVN_RA_SVN__WRITEBUF_SIZE (4 * SVN_RA_SVN__PAGE_SIZE)
  69
  70 /* Create forward reference */
  71 typedef struct svn_ra_svn__session_baton_t svn_ra_svn__session_baton_t;
  72
  73 /* This structure is opaque to the server.  The client pokes at the
  74  * first few fields during setup and cleanup. */
  75 struct svn_ra_svn_conn_st {
  76
  77   /* I/O buffers */
  78   char write_buf[SVN_RA_SVN__WRITEBUF_SIZE];
  79   char read_buf[SVN_RA_SVN__READBUF_SIZE];
  80   char *read_ptr;
  81   char *read_end;
  82   apr_size_t write_pos;
  83
  84   svn_ra_svn__stream_t *stream;
  85   svn_ra_svn__session_baton_t *session;
  86 #ifdef SVN_HAVE_SASL
  87   /* Although all reads and writes go through the svn_ra_svn__stream_t
  88      interface, SASL still needs direct access to the underlying socket
  89      for stuff like IP addresses and port numbers. */
  90   apr_socket_t *sock;
  91   svn_boolean_t encrypted;
  92 #endif
  93
  94   /* abortion check control */
  95   apr_size_t written_since_error_check;
  96   apr_size_t error_check_interval;
  97   svn_boolean_t may_check_for_error;
  98
  99   /* I/O limits and tracking */
 100   apr_uint64_t max_in;
 101   apr_uint64_t current_in;
 102   apr_uint64_t max_out;
 103   apr_uint64_t current_out;
 104
 105   /* repository info */
 106   const char *uuid;
 107   const char *repos_root;
 108
 109   /* TX block notification target */
 110   ra_svn_block_handler_t block_handler;
 111   void *block_baton;
 112
 113   /* server settings */
 114   apr_hash_t *capabilities;
 115   int compression_level;
 116   apr_size_t zero_copy_limit;
 117
 118   /* who's on the other side of the connection? */
 119   char *remote_ip;
 120
 121   /* EV2 support*/
 122   svn_delta_shim_callbacks_t *shim_callbacks;
 123
 124   /* our pool */
 125   apr_pool_t *pool;
 126 };
 127
 128 /* The session's URL state for client and server side.
 129  *
 130  * This keeps track of the respective client-side and server-side "parent"
 131  * URLs.  It tells us whether we may have to send reparent commands to the
 132  * server and how to tweak path parameters when we decided to handle
 133  * reparent requests on the client side only. */
 134 typedef struct svn_ra_svn__parent_t {
 135   /* Client-side session base URL, i.e. client's parent path. */
 136   svn_stringbuf_t *client_url;
 137
 138   /* Server-side base URL, i.e. server's parent path. */
 139   svn_stringbuf_t *server_url;
 140
 141   /* Relative path to add to a client-side parameter to translate it for the
 142    * server-side.  I.e. the relative path from SERVER_URL to CLIENT_URL. */
 143   svn_stringbuf_t *path;
 144 } svn_ra_svn__parent_t;
 145
 146 struct svn_ra_svn__session_baton_t {
 147   apr_pool_t *pool;
 148   svn_ra_svn_conn_t *conn;
 149   svn_boolean_t is_tunneled;
 150   svn_auth_baton_t *auth_baton;
 151   svn_ra_svn__parent_t *parent;
 152   const char *user;
 153   const char *hostname; /* The remote hostname. */
 154   const char *realm_prefix;
 155   const char *tunnel_name;
 156   const char **tunnel_argv;
 157   const svn_ra_callbacks2_t *callbacks;
 158   void *callbacks_baton;
 159   apr_hash_t *config;
 160   apr_off_t bytes_read, bytes_written; /* apr_off_t's because that's what
 161                                           the callback interface uses */
 162   const char *useragent;
 163 };
 164
 165 /* Set a callback for blocked writes on conn.  This handler may
 166  * perform reads on the connection in order to prevent deadlock due to
 167  * pipelining.  If callback is NULL, the connection goes back to
 168  * normal blocking I/O for writes.
 169  */
 170 void svn_ra_svn__set_block_handler(svn_ra_svn_conn_t *conn,
 171                                    ra_svn_block_handler_t callback,
 172                                    void *baton);
 173
 174 /* Return true if there is input waiting on conn. */
 175 svn_error_t *svn_ra_svn__data_available(svn_ra_svn_conn_t *conn,
 176                                        svn_boolean_t *data_available);
 177
 178 /* Signal a new request / response pair on CONN.  That resets the I/O
 179  * counters we use to limit the size of individual requests / response pairs.
 180  */
 181 void
 182 svn_ra_svn__reset_command_io_counters(svn_ra_svn_conn_t *conn);
 183
 184 /* CRAM-MD5 client implementation. */
 185 svn_error_t *svn_ra_svn__cram_client(svn_ra_svn_conn_t *conn, apr_pool_t *pool,
 186                                      const char *user, const char *password,
 187                                      const char **message);
 188
 189 /* Return a pointer to the error chain child of ERR which contains the
 190  * first "real" error message, not merely one of the
 191  * SVN_ERR_RA_SVN_CMD_ERR wrapper errors. */
 192 svn_error_t *svn_ra_svn__locate_real_error_child(svn_error_t *err);
 193
 194 /* Return an error chain based on @a params (which contains a
 195  * command response indicating failure).  The error chain will be
 196  * in the same order as the errors indicated in @a params. */
 197 svn_error_t *
 198 svn_ra_svn__handle_failure_status(const svn_ra_svn__list_t *params);
 199
 200 /* Returns a stream that reads/writes from/to SOCK. */
 201 svn_ra_svn__stream_t *svn_ra_svn__stream_from_sock(apr_socket_t *sock,
 202                                                    apr_pool_t *pool);
 203
 204 /* Returns a stream that reads from IN_STREAM and writes to OUT_STREAM,
 205    creating a timeout callback for OUT_STREAM if possible  */
 206 svn_ra_svn__stream_t *svn_ra_svn__stream_from_streams(svn_stream_t *in_stream,
 207                                                       svn_stream_t *out_stream,
 208                                                       apr_pool_t *pool);
 209
 210 /* Create an svn_ra_svn__stream_t using READ_CB, WRITE_CB, TIMEOUT_CB,
 211  * PENDING_CB, and BATON.
 212  */
 213 svn_ra_svn__stream_t *svn_ra_svn__stream_create(svn_stream_t *in_stream,
 214                                                 svn_stream_t *out_stream,
 215                                                 void *timeout_baton,
 216                                                 ra_svn_timeout_fn_t timeout_cb,
 217                                                 apr_pool_t *result_pool);
 218
 219 /* Write *LEN bytes from DATA to STREAM, returning the number of bytes
 220  * written in *LEN.
 221  */
 222 svn_error_t *svn_ra_svn__stream_write(svn_ra_svn__stream_t *stream,
 223                                       const char *data, apr_size_t *len);
 224
 225 /* Read *LEN bytes from STREAM into DATA, returning the number of bytes
 226  * read in *LEN.
 227  */
 228 svn_error_t *svn_ra_svn__stream_read(svn_ra_svn__stream_t *stream,
 229                                      char *data, apr_size_t *len);
 230
 231 /* Read the command word from CONN, return it in *COMMAND and skip to the
 232  * end of the command.  Allocate data in POOL.
 233  */
 234 svn_error_t *svn_ra_svn__read_command_only(svn_ra_svn_conn_t *conn,
 235                                            apr_pool_t *pool,
 236                                            const char **command);
 237
 238 /* Set the timeout for operations on STREAM to INTERVAL. */
 239 void svn_ra_svn__stream_timeout(svn_ra_svn__stream_t *stream,
 240                                 apr_interval_time_t interval);
 241
 242 /* Return whether or not there is data pending on STREAM. */
 243 svn_error_t *
 244 svn_ra_svn__stream_data_available(svn_ra_svn__stream_t *stream,
 245                                   svn_boolean_t *data_available);
 246
 247 /* Respond to an auth request and perform authentication.  Use the Cyrus
 248  * SASL library for mechanism negotiation and for creating authentication
 249  * tokens. */
 250 svn_error_t *
 251 svn_ra_svn__do_cyrus_auth(svn_ra_svn__session_baton_t *sess,
 252                           const svn_ra_svn__list_t *mechlist,
 253                           const char *realm, apr_pool_t *pool);
 254
 255 /* Same as svn_ra_svn__do_cyrus_auth, but uses the built-in implementation of
 256  * the CRAM-MD5, ANONYMOUS and EXTERNAL mechanisms.  Return the error
 257  * SVN_ERR_RA_SVN_NO_MECHANSIMS if we cannot negotiate an authentication
 258  * mechanism with the server. */
 259 svn_error_t *
 260 svn_ra_svn__do_internal_auth(svn_ra_svn__session_baton_t *sess,
 261                              const svn_ra_svn__list_t *mechlist,
 262                              const char *realm, apr_pool_t *pool);
 263
 264 /* Having picked a mechanism, start authentication by writing out an
 265  * auth response.  MECH_ARG may be NULL for mechanisms with no
 266  * initial client response. */
 267 svn_error_t *svn_ra_svn__auth_response(svn_ra_svn_conn_t *conn,
 268                                        apr_pool_t *pool,
 269                                        const char *mech, const char *mech_arg);
 270
 271 /* Looks for MECH as a word in MECHLIST. */
 272 svn_boolean_t svn_ra_svn__find_mech(const svn_ra_svn__list_t *mechlist,
 273                                     const char *mech);
 274
 275 /* Initialize the SASL library. */
 276 svn_error_t *svn_ra_svn__sasl_init(void);
 277
 278
 279 #ifdef __cplusplus
 280 }
 281 #endif /* __cplusplus */
 282
 283 #endif  /* RA_SVN_H */