subversion/libsvn_ra_svn/ra_svn.h - subversion - Git at Google

 /*
  * ra_svn.h :  private declarations for the ra_svn module
  *
  * ====================================================================
  *    Licensed to the Apache Software Foundation (ASF) under one
  *    or more contributor license agreements.  See the NOTICE file
  *    distributed with this work for additional information
  *    regarding copyright ownership.  The ASF licenses this file
  *    to you under the Apache License, Version 2.0 (the
  *    "License"); you may not use this file except in compliance
  *    with the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  *    Unless required by applicable law or agreed to in writing,
  *    software distributed under the License is distributed on an
  *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  *    KIND, either express or implied.  See the License for the
  *    specific language governing permissions and limitations
  *    under the License.
  * ====================================================================
  */


 #ifndef RA_SVN_H
 #define RA_SVN_H

 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */

 #include <apr_network_io.h>
 #include <apr_file_io.h>
 #include <apr_thread_proc.h>
 #include "svn_ra.h"
 #include "svn_ra_svn.h"

 #include "private/svn_ra_svn_private.h"

 /* Callback function that indicates if a svn_ra_svn__stream_t has pending
  * data.
  */
 typedef svn_boolean_t (*ra_svn_pending_fn_t)(void *baton);

 /* Callback function that sets the timeout value for a svn_ra_svn__stream_t. */
 typedef void (*ra_svn_timeout_fn_t)(void *baton, apr_interval_time_t timeout);

 /* A stream abstraction for ra_svn.
  *
  * This is different from svn_stream_t in that it provides timeouts and
  * the ability to check for pending data.
  */
 typedef struct svn_ra_svn__stream_st svn_ra_svn__stream_t;

 /* Handler for blocked writes. */
 typedef svn_error_t *(*ra_svn_block_handler_t)(svn_ra_svn_conn_t *conn,
                                                apr_pool_t *pool,
                                                void *baton);

 /* The default "user agent". */
 #define SVN_RA_SVN__DEFAULT_USERAGENT  "SVN/" SVN_VER_NUMBER\
                                        " (" SVN_BUILD_TARGET ")"

 /* The size of our per-connection read and write buffers. */
 #define SVN_RA_SVN__PAGE_SIZE 4096
 #define SVN_RA_SVN__READBUF_SIZE (4 * SVN_RA_SVN__PAGE_SIZE)
 #define SVN_RA_SVN__WRITEBUF_SIZE (4 * SVN_RA_SVN__PAGE_SIZE)

 /* Create forward reference */
 typedef struct svn_ra_svn__session_baton_t svn_ra_svn__session_baton_t;

 /* This structure is opaque to the server.  The client pokes at the
  * first few fields during setup and cleanup. */
 struct svn_ra_svn_conn_st {

   /* I/O buffers */
   char write_buf[SVN_RA_SVN__WRITEBUF_SIZE];
   char read_buf[SVN_RA_SVN__READBUF_SIZE];
   char *read_ptr;
   char *read_end;
   apr_size_t write_pos;

   svn_ra_svn__stream_t *stream;
   svn_ra_svn__session_baton_t *session;
 #ifdef SVN_HAVE_SASL
   /* Although all reads and writes go through the svn_ra_svn__stream_t
      interface, SASL still needs direct access to the underlying socket
      for stuff like IP addresses and port numbers. */
   apr_socket_t *sock;
   svn_boolean_t encrypted;
 #endif

   /* abortion check control */
   apr_size_t written_since_error_check;
   apr_size_t error_check_interval;
   svn_boolean_t may_check_for_error;

   /* I/O limits and tracking */
   apr_uint64_t max_in;
   apr_uint64_t current_in;
   apr_uint64_t max_out;
   apr_uint64_t current_out;

   /* repository info */
   const char *uuid;
   const char *repos_root;

   /* TX block notification target */
   ra_svn_block_handler_t block_handler;
   void *block_baton;

   /* server settings */
   apr_hash_t *capabilities;
   int compression_level;
   apr_size_t zero_copy_limit;

   /* who's on the other side of the connection? */
   char *remote_ip;

   /* EV2 support*/
   svn_delta_shim_callbacks_t *shim_callbacks;

   /* our pool */
   apr_pool_t *pool;
 };

 struct svn_ra_svn__session_baton_t {
   apr_pool_t *pool;
   svn_ra_svn_conn_t *conn;
   svn_boolean_t is_tunneled;
   svn_auth_baton_t *auth_baton;
   const char *url;
   const char *user;
   const char *hostname; /* The remote hostname. */
   const char *realm_prefix;
   const char *tunnel_name;
   const char **tunnel_argv;
   const svn_ra_callbacks2_t *callbacks;
   void *callbacks_baton;
   apr_hash_t *config;
   apr_off_t bytes_read, bytes_written; /* apr_off_t's because that's what
                                           the callback interface uses */
   const char *useragent;
 };

 /* Set a callback for blocked writes on conn.  This handler may
  * perform reads on the connection in order to prevent deadlock due to
  * pipelining.  If callback is NULL, the connection goes back to
  * normal blocking I/O for writes.
  */
 void svn_ra_svn__set_block_handler(svn_ra_svn_conn_t *conn,
                                    ra_svn_block_handler_t callback,
                                    void *baton);

 /* Return true if there is input waiting on conn. */
 svn_error_t *svn_ra_svn__data_available(svn_ra_svn_conn_t *conn,
                                        svn_boolean_t *data_available);

 /* Signal a new request / response pair on CONN.  That resets the I/O
  * counters we use to limit the size of individual requests / response pairs.
  */
 void
 svn_ra_svn__reset_command_io_counters(svn_ra_svn_conn_t *conn);

 /* CRAM-MD5 client implementation. */
 svn_error_t *svn_ra_svn__cram_client(svn_ra_svn_conn_t *conn, apr_pool_t *pool,
                                      const char *user, const char *password,
                                      const char **message);

 /* Return a pointer to the error chain child of ERR which contains the
  * first "real" error message, not merely one of the
  * SVN_ERR_RA_SVN_CMD_ERR wrapper errors. */
 svn_error_t *svn_ra_svn__locate_real_error_child(svn_error_t *err);

 /* Return an error chain based on @a params (which contains a
  * command response indicating failure).  The error chain will be
  * in the same order as the errors indicated in @a params. */
 svn_error_t *
 svn_ra_svn__handle_failure_status(const svn_ra_svn__list_t *params);

 /* Returns a stream that reads/writes from/to SOCK. */
 svn_ra_svn__stream_t *svn_ra_svn__stream_from_sock(apr_socket_t *sock,
                                                    apr_pool_t *pool);

 /* Returns a stream that reads from IN_STREAM and writes to OUT_STREAM,
    creating a timeout callback for OUT_STREAM if possible  */
 svn_ra_svn__stream_t *svn_ra_svn__stream_from_streams(svn_stream_t *in_stream,
                                                       svn_stream_t *out_stream,
                                                       apr_pool_t *pool);

 /* Create an svn_ra_svn__stream_t using READ_CB, WRITE_CB, TIMEOUT_CB,
  * PENDING_CB, and BATON.
  */
 svn_ra_svn__stream_t *svn_ra_svn__stream_create(svn_stream_t *in_stream,
                                                 svn_stream_t *out_stream,
                                                 void *timeout_baton,
                                                 ra_svn_timeout_fn_t timeout_cb,
                                                 apr_pool_t *result_pool);

 /* Write *LEN bytes from DATA to STREAM, returning the number of bytes
  * written in *LEN.
  */
 svn_error_t *svn_ra_svn__stream_write(svn_ra_svn__stream_t *stream,
                                       const char *data, apr_size_t *len);

 /* Read *LEN bytes from STREAM into DATA, returning the number of bytes
  * read in *LEN.
  */
 svn_error_t *svn_ra_svn__stream_read(svn_ra_svn__stream_t *stream,
                                      char *data, apr_size_t *len);

 /* Read the command word from CONN, return it in *COMMAND and skip to the
  * end of the command.  Allocate data in POOL.
  */
 svn_error_t *svn_ra_svn__read_command_only(svn_ra_svn_conn_t *conn,
                                            apr_pool_t *pool,
                                            const char **command);

 /* Set the timeout for operations on STREAM to INTERVAL. */
 void svn_ra_svn__stream_timeout(svn_ra_svn__stream_t *stream,
                                 apr_interval_time_t interval);

 /* Return whether or not there is data pending on STREAM. */
 svn_error_t *
 svn_ra_svn__stream_data_available(svn_ra_svn__stream_t *stream,
                                   svn_boolean_t *data_available);

 /* Respond to an auth request and perform authentication.  Use the Cyrus
  * SASL library for mechanism negotiation and for creating authentication
  * tokens. */
 svn_error_t *
 svn_ra_svn__do_cyrus_auth(svn_ra_svn__session_baton_t *sess,
                           const svn_ra_svn__list_t *mechlist,
                           const char *realm, apr_pool_t *pool);

 /* Same as svn_ra_svn__do_cyrus_auth, but uses the built-in implementation of
  * the CRAM-MD5, ANONYMOUS and EXTERNAL mechanisms.  Return the error
  * SVN_ERR_RA_SVN_NO_MECHANSIMS if we cannot negotiate an authentication
  * mechanism with the server. */
 svn_error_t *
 svn_ra_svn__do_internal_auth(svn_ra_svn__session_baton_t *sess,
                              const svn_ra_svn__list_t *mechlist,
                              const char *realm, apr_pool_t *pool);

 /* Having picked a mechanism, start authentication by writing out an
  * auth response.  MECH_ARG may be NULL for mechanisms with no
  * initial client response. */
 svn_error_t *svn_ra_svn__auth_response(svn_ra_svn_conn_t *conn,
                                        apr_pool_t *pool,
                                        const char *mech, const char *mech_arg);

 /* Looks for MECH as a word in MECHLIST. */
 svn_boolean_t svn_ra_svn__find_mech(const svn_ra_svn__list_t *mechlist,
                                     const char *mech);

 /* Initialize the SASL library. */
 svn_error_t *svn_ra_svn__sasl_init(void);


 #ifdef __cplusplus
 }
 #endif /* __cplusplus */

 #endif  /* RA_SVN_H */
	/*
	* ra_svn.h : private declarations for the ra_svn module
	*
	* ====================================================================
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	* ====================================================================
	*/



	#ifndef RA_SVN_H
	#define RA_SVN_H

	#ifdef __cplusplus
	extern "C" {
	#endif /* __cplusplus */

	#include <apr_network_io.h>
	#include <apr_file_io.h>
	#include <apr_thread_proc.h>
	#include "svn_ra.h"
	#include "svn_ra_svn.h"

	#include "private/svn_ra_svn_private.h"

	/* Callback function that indicates if a svn_ra_svn__stream_t has pending
	* data.
	*/
	typedef svn_boolean_t (ra_svn_pending_fn_t)(void baton);

	/* Callback function that sets the timeout value for a svn_ra_svn__stream_t. */
	typedef void (ra_svn_timeout_fn_t)(void baton, apr_interval_time_t timeout);

	/* A stream abstraction for ra_svn.
	*
	* This is different from svn_stream_t in that it provides timeouts and
	* the ability to check for pending data.
	*/
	typedef struct svn_ra_svn__stream_st svn_ra_svn__stream_t;

	/* Handler for blocked writes. */
	typedef svn_error_t (ra_svn_block_handler_t)(svn_ra_svn_conn_t *conn,
	apr_pool_t *pool,
	void *baton);

	/* The default "user agent". */
	#define SVN_RA_SVN__DEFAULT_USERAGENT "SVN/" SVN_VER_NUMBER\
	" (" SVN_BUILD_TARGET ")"

	/* The size of our per-connection read and write buffers. */
	#define SVN_RA_SVN__PAGE_SIZE 4096
	#define SVN_RA_SVN__READBUF_SIZE (4 * SVN_RA_SVN__PAGE_SIZE)
	#define SVN_RA_SVN__WRITEBUF_SIZE (4 * SVN_RA_SVN__PAGE_SIZE)

	/* Create forward reference */
	typedef struct svn_ra_svn__session_baton_t svn_ra_svn__session_baton_t;

	/* This structure is opaque to the server. The client pokes at the
	* first few fields during setup and cleanup. */
	struct svn_ra_svn_conn_st {

	/* I/O buffers */
	char write_buf[SVN_RA_SVN__WRITEBUF_SIZE];
	char read_buf[SVN_RA_SVN__READBUF_SIZE];
	char *read_ptr;
	char *read_end;
	apr_size_t write_pos;

	svn_ra_svn__stream_t *stream;
	svn_ra_svn__session_baton_t *session;
	#ifdef SVN_HAVE_SASL
	/* Although all reads and writes go through the svn_ra_svn__stream_t
	interface, SASL still needs direct access to the underlying socket
	for stuff like IP addresses and port numbers. */
	apr_socket_t *sock;
	svn_boolean_t encrypted;
	#endif

	/* abortion check control */
	apr_size_t written_since_error_check;
	apr_size_t error_check_interval;
	svn_boolean_t may_check_for_error;

	/* I/O limits and tracking */
	apr_uint64_t max_in;
	apr_uint64_t current_in;
	apr_uint64_t max_out;
	apr_uint64_t current_out;

	/* repository info */
	const char *uuid;
	const char *repos_root;

	/* TX block notification target */
	ra_svn_block_handler_t block_handler;
	void *block_baton;

	/* server settings */
	apr_hash_t *capabilities;
	int compression_level;
	apr_size_t zero_copy_limit;

	/* who's on the other side of the connection? */
	char *remote_ip;

	/* EV2 support*/
	svn_delta_shim_callbacks_t *shim_callbacks;

	/* our pool */
	apr_pool_t *pool;
	};

	struct svn_ra_svn__session_baton_t {
	apr_pool_t *pool;
	svn_ra_svn_conn_t *conn;
	svn_boolean_t is_tunneled;
	svn_auth_baton_t *auth_baton;
	const char *url;
	const char *user;
	const char hostname; / The remote hostname. */
	const char *realm_prefix;
	const char *tunnel_name;
	const char **tunnel_argv;
	const svn_ra_callbacks2_t *callbacks;
	void *callbacks_baton;
	apr_hash_t *config;
	apr_off_t bytes_read, bytes_written; /* apr_off_t's because that's what
	the callback interface uses */
	const char *useragent;
	};

	/* Set a callback for blocked writes on conn. This handler may
	* perform reads on the connection in order to prevent deadlock due to
	* pipelining. If callback is NULL, the connection goes back to
	* normal blocking I/O for writes.
	*/
	void svn_ra_svn__set_block_handler(svn_ra_svn_conn_t *conn,
	ra_svn_block_handler_t callback,
	void *baton);

	/* Return true if there is input waiting on conn. */
	svn_error_t svn_ra_svn__data_available(svn_ra_svn_conn_t conn,
	svn_boolean_t *data_available);

	/* Signal a new request / response pair on CONN. That resets the I/O
	* counters we use to limit the size of individual requests / response pairs.
	*/
	void
	svn_ra_svn__reset_command_io_counters(svn_ra_svn_conn_t *conn);

	/* CRAM-MD5 client implementation. */
	svn_error_t svn_ra_svn__cram_client(svn_ra_svn_conn_t conn, apr_pool_t *pool,
	const char user, const char password,
	const char **message);

	/* Return a pointer to the error chain child of ERR which contains the
	* first "real" error message, not merely one of the
	* SVN_ERR_RA_SVN_CMD_ERR wrapper errors. */
	svn_error_t svn_ra_svn__locate_real_error_child(svn_error_t err);

	/* Return an error chain based on @a params (which contains a
	* command response indicating failure). The error chain will be
	* in the same order as the errors indicated in @a params. */
	svn_error_t *
	svn_ra_svn__handle_failure_status(const svn_ra_svn__list_t *params);

	/* Returns a stream that reads/writes from/to SOCK. */
	svn_ra_svn__stream_t svn_ra_svn__stream_from_sock(apr_socket_t sock,
	apr_pool_t *pool);

	/* Returns a stream that reads from IN_STREAM and writes to OUT_STREAM,
	creating a timeout callback for OUT_STREAM if possible */
	svn_ra_svn__stream_t svn_ra_svn__stream_from_streams(svn_stream_t in_stream,
	svn_stream_t *out_stream,
	apr_pool_t *pool);

	/* Create an svn_ra_svn__stream_t using READ_CB, WRITE_CB, TIMEOUT_CB,
	* PENDING_CB, and BATON.
	*/
	svn_ra_svn__stream_t svn_ra_svn__stream_create(svn_stream_t in_stream,
	svn_stream_t *out_stream,
	void *timeout_baton,
	ra_svn_timeout_fn_t timeout_cb,
	apr_pool_t *result_pool);

	/* Write *LEN bytes from DATA to STREAM, returning the number of bytes
	* written in *LEN.
	*/
	svn_error_t svn_ra_svn__stream_write(svn_ra_svn__stream_t stream,
	const char data, apr_size_t len);

	/* Read *LEN bytes from STREAM into DATA, returning the number of bytes
	* read in *LEN.
	*/
	svn_error_t svn_ra_svn__stream_read(svn_ra_svn__stream_t stream,
	char data, apr_size_t len);

	/* Read the command word from CONN, return it in *COMMAND and skip to the
	* end of the command. Allocate data in POOL.
	*/
	svn_error_t svn_ra_svn__read_command_only(svn_ra_svn_conn_t conn,
	apr_pool_t *pool,
	const char **command);

	/* Set the timeout for operations on STREAM to INTERVAL. */
	void svn_ra_svn__stream_timeout(svn_ra_svn__stream_t *stream,
	apr_interval_time_t interval);

	/* Return whether or not there is data pending on STREAM. */
	svn_error_t *
	svn_ra_svn__stream_data_available(svn_ra_svn__stream_t *stream,
	svn_boolean_t *data_available);

	/* Respond to an auth request and perform authentication. Use the Cyrus
	* SASL library for mechanism negotiation and for creating authentication
	* tokens. */
	svn_error_t *
	svn_ra_svn__do_cyrus_auth(svn_ra_svn__session_baton_t *sess,
	const svn_ra_svn__list_t *mechlist,
	const char realm, apr_pool_t pool);

	/* Same as svn_ra_svn__do_cyrus_auth, but uses the built-in implementation of
	* the CRAM-MD5, ANONYMOUS and EXTERNAL mechanisms. Return the error
	* SVN_ERR_RA_SVN_NO_MECHANSIMS if we cannot negotiate an authentication
	* mechanism with the server. */
	svn_error_t *
	svn_ra_svn__do_internal_auth(svn_ra_svn__session_baton_t *sess,
	const svn_ra_svn__list_t *mechlist,
	const char realm, apr_pool_t pool);

	/* Having picked a mechanism, start authentication by writing out an
	* auth response. MECH_ARG may be NULL for mechanisms with no
	* initial client response. */
	svn_error_t svn_ra_svn__auth_response(svn_ra_svn_conn_t conn,
	apr_pool_t *pool,
	const char mech, const char mech_arg);

	/* Looks for MECH as a word in MECHLIST. */
	svn_boolean_t svn_ra_svn__find_mech(const svn_ra_svn__list_t *mechlist,
	const char *mech);

	/* Initialize the SASL library. */
	svn_error_t *svn_ra_svn__sasl_init(void);


	#ifdef __cplusplus
	}
	#endif /* __cplusplus */

	#endif /* RA_SVN_H */