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 26#ifndef RA_SVN_H 27#define RA_SVN_H 28 29#ifdef __cplusplus 30extern "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 */ 44typedef 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. */ 47typedef 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 */ 54typedef struct svn_ra_svn__stream_st svn_ra_svn__stream_t; 55 56/* Handler for blocked writes. */ 57typedef 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 */ 71typedef 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. */ 75struct 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 /* repository info */ 100 const char *uuid; 101 const char *repos_root; 102 103 /* TX block notification target */ 104 ra_svn_block_handler_t block_handler; 105 void *block_baton; 106 107 /* server settings */ 108 apr_hash_t *capabilities; 109 int compression_level; 110 apr_size_t zero_copy_limit; 111 112 /* who's on the other side of the connection? */ 113 char *remote_ip; 114 115 /* EV2 support*/ 116 svn_delta_shim_callbacks_t *shim_callbacks; 117 118 /* our pool */ 119 apr_pool_t *pool; 120}; 121 122struct svn_ra_svn__session_baton_t { 123 apr_pool_t *pool; 124 svn_ra_svn_conn_t *conn; 125 svn_boolean_t is_tunneled; 126 const char *url; 127 const char *user; 128 const char *hostname; /* The remote hostname. */ 129 const char *realm_prefix; 130 const char **tunnel_argv; 131 const svn_ra_callbacks2_t *callbacks; 132 void *callbacks_baton; 133 apr_off_t bytes_read, bytes_written; /* apr_off_t's because that's what 134 the callback interface uses */ 135 const char *useragent; 136}; 137 138/* Set a callback for blocked writes on conn. This handler may 139 * perform reads on the connection in order to prevent deadlock due to 140 * pipelining. If callback is NULL, the connection goes back to 141 * normal blocking I/O for writes. 142 */ 143void svn_ra_svn__set_block_handler(svn_ra_svn_conn_t *conn, 144 ra_svn_block_handler_t callback, 145 void *baton); 146 147/* Return true if there is input waiting on conn. */ 148svn_boolean_t svn_ra_svn__input_waiting(svn_ra_svn_conn_t *conn, 149 apr_pool_t *pool); 150 151/* CRAM-MD5 client implementation. */ 152svn_error_t *svn_ra_svn__cram_client(svn_ra_svn_conn_t *conn, apr_pool_t *pool, 153 const char *user, const char *password, 154 const char **message); 155 156/* Return a pointer to the error chain child of ERR which contains the 157 * first "real" error message, not merely one of the 158 * SVN_ERR_RA_SVN_CMD_ERR wrapper errors. */ 159svn_error_t *svn_ra_svn__locate_real_error_child(svn_error_t *err); 160 161/* Return an error chain based on @a params (which contains a 162 * command response indicating failure). The error chain will be 163 * in the same order as the errors indicated in @a params. Use 164 * @a pool for temporary allocations. */ 165svn_error_t *svn_ra_svn__handle_failure_status(const apr_array_header_t *params, 166 apr_pool_t *pool); 167 168/* Returns a stream that reads/writes from/to SOCK. */ 169svn_ra_svn__stream_t *svn_ra_svn__stream_from_sock(apr_socket_t *sock, 170 apr_pool_t *pool); 171 172/* Returns a stream that reads from IN_FILE and writes to OUT_FILE. */ 173svn_ra_svn__stream_t *svn_ra_svn__stream_from_files(apr_file_t *in_file, 174 apr_file_t *out_file, 175 apr_pool_t *pool); 176 177/* Create an svn_ra_svn__stream_t using READ_CB, WRITE_CB, TIMEOUT_CB, 178 * PENDING_CB, and BATON. 179 */ 180svn_ra_svn__stream_t *svn_ra_svn__stream_create(void *baton, 181 svn_read_fn_t read_cb, 182 svn_write_fn_t write_cb, 183 ra_svn_timeout_fn_t timeout_cb, 184 ra_svn_pending_fn_t pending_cb, 185 apr_pool_t *pool); 186 187/* Write *LEN bytes from DATA to STREAM, returning the number of bytes 188 * written in *LEN. 189 */ 190svn_error_t *svn_ra_svn__stream_write(svn_ra_svn__stream_t *stream, 191 const char *data, apr_size_t *len); 192 193/* Read *LEN bytes from STREAM into DATA, returning the number of bytes 194 * read in *LEN. 195 */ 196svn_error_t *svn_ra_svn__stream_read(svn_ra_svn__stream_t *stream, 197 char *data, apr_size_t *len); 198 199/* Read the command word from CONN, return it in *COMMAND and skip to the 200 * end of the command. Allocate data in POOL. 201 */ 202svn_error_t *svn_ra_svn__read_command_only(svn_ra_svn_conn_t *conn, 203 apr_pool_t *pool, 204 const char **command); 205 206/* Set the timeout for operations on STREAM to INTERVAL. */ 207void svn_ra_svn__stream_timeout(svn_ra_svn__stream_t *stream, 208 apr_interval_time_t interval); 209 210/* Return whether or not there is data pending on STREAM. */ 211svn_boolean_t svn_ra_svn__stream_pending(svn_ra_svn__stream_t *stream); 212 213/* Respond to an auth request and perform authentication. Use the Cyrus 214 * SASL library for mechanism negotiation and for creating authentication 215 * tokens. */ 216svn_error_t * 217svn_ra_svn__do_cyrus_auth(svn_ra_svn__session_baton_t *sess, 218 const apr_array_header_t *mechlist, 219 const char *realm, apr_pool_t *pool); 220 221/* Same as svn_ra_svn__do_cyrus_auth, but uses the built-in implementation of 222 * the CRAM-MD5, ANONYMOUS and EXTERNAL mechanisms. Return the error 223 * SVN_ERR_RA_SVN_NO_MECHANSIMS if we cannot negotiate an authentication 224 * mechanism with the server. */ 225svn_error_t * 226svn_ra_svn__do_internal_auth(svn_ra_svn__session_baton_t *sess, 227 const apr_array_header_t *mechlist, 228 const char *realm, apr_pool_t *pool); 229 230/* Having picked a mechanism, start authentication by writing out an 231 * auth response. MECH_ARG may be NULL for mechanisms with no 232 * initial client response. */ 233svn_error_t *svn_ra_svn__auth_response(svn_ra_svn_conn_t *conn, 234 apr_pool_t *pool, 235 const char *mech, const char *mech_arg); 236 237/* Looks for MECH as a word in MECHLIST (an array of svn_ra_svn_item_t). */ 238svn_boolean_t svn_ra_svn__find_mech(const apr_array_header_t *mechlist, 239 const char *mech); 240 241/* Initialize the SASL library. */ 242svn_error_t *svn_ra_svn__sasl_init(void); 243 244 245#ifdef __cplusplus 246} 247#endif /* __cplusplus */ 248 249#endif /* RA_SVN_H */ 250