Modified: subversion/branches/compressed-pristines/subversion/libsvn_subr/named_atomic.c URL: http://svn.apache.org/viewvc/subversion/branches/compressed-pristines/subversion/libsvn_subr/named_atomic.c?rev=1413258&r1=1413257&r2=1413258&view=diff ============================================================================== --- subversion/branches/compressed-pristines/subversion/libsvn_subr/named_atomic.c (original) +++ subversion/branches/compressed-pristines/subversion/libsvn_subr/named_atomic.c Sat Nov 24 20:29:11 2012 @@ -24,7 +24,7 @@ #include "private/svn_named_atomic.h" #include <apr_global_mutex.h> -#include <apr_shm.h> +#include <apr_mmap.h> #include "svn_private_config.h" #include "private/svn_atomic.h" @@ -35,13 +35,16 @@ /* Implementation aspects. * - * We use a single shared memory block that will be created by the first - * user and merely mapped by all subsequent ones. The memory block contains - * an short header followed by a fixed-capacity array of named atomics. The - * number of entries currently in use is stored in the header part. + * We use a single shared memory block (memory mapped file) that will be + * created by the first user and merely mapped by all subsequent ones. + * The memory block contains an short header followed by a fixed-capacity + * array of named atomics. The number of entries currently in use is stored + * in the header part. * - * Finding / creating the SHM object as well as adding new array entries - * is being guarded by an APR global mutex. + * Finding / creating the MMAP object as well as adding new array entries + * is being guarded by an APR global mutex. Since releasing the MMAP + * structure and closing the underlying does not affect other users of the + * same, cleanup will not be synchronized. * * The array is append-only. Once a process mapped the block into its * address space, it may freely access any of the used entries. However, @@ -182,8 +185,8 @@ struct named_atomic_data_t */ struct shared_data_t { - volatile apr_int32_t count; - char padding [sizeof(struct named_atomic_data_t) - sizeof(apr_int32_t)]; + volatile apr_uint32_t count; + char padding [sizeof(struct named_atomic_data_t) - sizeof(apr_uint32_t)]; struct named_atomic_data_t atomics[MAX_ATOMIC_COUNT]; }; @@ -382,8 +385,13 @@ svn_atomic_namespace__create(svn_atomic_ apr_pool_t *result_pool) { apr_status_t apr_err; + svn_error_t *err; + apr_file_t *file; + apr_mmap_t *mmap; const char *shm_name, *lock_name; - apr_shm_t *shared_mem; + apr_finfo_t finfo; + + apr_pool_t *subpool = svn_pool_create(result_pool); /* allocate the namespace data structure */ @@ -391,15 +399,13 @@ svn_atomic_namespace__create(svn_atomic_ /* construct the names of the system objects that we need */ - shm_name = apr_pstrcat(result_pool, name, SHM_NAME_SUFFIX, NULL); - lock_name = apr_pstrcat(result_pool, name, MUTEX_NAME_SUFFIX, NULL); + shm_name = apr_pstrcat(subpool, name, SHM_NAME_SUFFIX, NULL); + lock_name = apr_pstrcat(subpool, name, MUTEX_NAME_SUFFIX, NULL); /* initialize the lock objects */ - svn_atomic__init_once(&mutex_initialized, - init_thread_mutex, - NULL, - result_pool); + SVN_ERR(svn_atomic__init_once(&mutex_initialized, init_thread_mutex, NULL, + result_pool)); new_ns->mutex.pool = result_pool; SVN_ERR(svn_io_file_open(&new_ns->mutex.lock_file, lock_name, @@ -417,42 +423,80 @@ svn_atomic_namespace__create(svn_atomic_ */ SVN_ERR(lock(&new_ns->mutex)); - /* First, look for an existing shared memory object. If it doesn't - * exist, create one. + /* First, make sure that the underlying file exists. If it doesn't + * exist, create one and initialize its content. + */ + err = svn_io_file_open(&file, shm_name, + APR_READ | APR_WRITE | APR_CREATE, + APR_OS_DEFAULT, + result_pool); + if (!err) + { + err = svn_io_stat(&finfo, shm_name, APR_FINFO_SIZE, subpool); + if (!err && finfo.size < sizeof(struct shared_data_t)) + { + /* Zero all counters, values and names. + */ + struct shared_data_t initial_data; + memset(&initial_data, 0, sizeof(initial_data)); + err = svn_io_file_write_full(file, &initial_data, + sizeof(initial_data), NULL, + subpool); + } + } + + /* Now, map it into memory. */ - apr_err = apr_shm_attach(&shared_mem, shm_name, result_pool); - if (apr_err) + if (!err) { - apr_err = apr_shm_create(&shared_mem, - sizeof(*new_ns->data), - shm_name, - result_pool); - if (apr_err) - return unlock(&new_ns->mutex, - svn_error_wrap_apr(apr_err, - _("Can't get shared memory for named atomics"))); + apr_err = apr_mmap_create(&mmap, file, 0, sizeof(*new_ns->data), + APR_MMAP_READ | APR_MMAP_WRITE , result_pool); + if (!apr_err) + new_ns->data = mmap->mm; + else + err = svn_error_createf(apr_err, NULL, + _("MMAP failed for file '%s'"), shm_name); + } - new_ns->data = apr_shm_baseaddr_get(shared_mem); + svn_pool_destroy(subpool); - /* Zero all counters, values and names. + if (!err && new_ns->data) + { + /* Sanitize (in case of data corruption) */ - memset(new_ns->data, 0, sizeof(*new_ns->data)); - } - else - new_ns->data = apr_shm_baseaddr_get(shared_mem); + if (new_ns->data->count > MAX_ATOMIC_COUNT) + new_ns->data->count = MAX_ATOMIC_COUNT; - /* Cache the number of existing, complete entries. There can't be - * incomplete ones from other processes because we hold the mutex. - * Our process will also not access this information since we are - * wither being called from within svn_atomic__init_once or by - * svn_atomic_namespace__create for a new object. - */ - new_ns->min_used = new_ns->data->count; + /* Cache the number of existing, complete entries. There can't be + * incomplete ones from other processes because we hold the mutex. + * Our process will also not access this information since we are + * either being called from within svn_atomic__init_once or by + * svn_atomic_namespace__create for a new object. + */ + new_ns->min_used = new_ns->data->count; + *ns = new_ns; + } /* Unlock to allow other processes may access the shared memory as well. */ - *ns = new_ns; - return unlock(&new_ns->mutex, SVN_NO_ERROR); + return unlock(&new_ns->mutex, err); +} + +svn_error_t * +svn_atomic_namespace__cleanup(const char *name, + apr_pool_t *pool) +{ + const char *shm_name, *lock_name; + + /* file names used for the specified namespace */ + shm_name = apr_pstrcat(pool, name, SHM_NAME_SUFFIX, NULL); + lock_name = apr_pstrcat(pool, name, MUTEX_NAME_SUFFIX, NULL); + + /* remove these files if they exist */ + SVN_ERR(svn_io_remove_file2(shm_name, TRUE, pool)); + SVN_ERR(svn_io_remove_file2(lock_name, TRUE, pool)); + + return SVN_NO_ERROR; } svn_error_t * @@ -461,7 +505,7 @@ svn_named_atomic__get(svn_named_atomic__ const char *name, svn_boolean_t auto_create) { - apr_int32_t i, count; + apr_uint32_t i, count; svn_error_t *error = SVN_NO_ERROR; apr_size_t len = strlen(name); @@ -499,7 +543,7 @@ svn_named_atomic__get(svn_named_atomic__ /* We only need to check for new entries. */ for (i = count; i < ns->data->count; ++i) - if (strcmp(ns->data->atomics[i].name, name) == 0) + if (strncmp(ns->data->atomics[i].name, name, len + 1) == 0) { return_atomic(atomic, ns, i);
Modified: subversion/branches/compressed-pristines/subversion/libsvn_subr/nls.c URL: http://svn.apache.org/viewvc/subversion/branches/compressed-pristines/subversion/libsvn_subr/nls.c?rev=1413258&r1=1413257&r2=1413258&view=diff ============================================================================== --- subversion/branches/compressed-pristines/subversion/libsvn_subr/nls.c (original) +++ subversion/branches/compressed-pristines/subversion/libsvn_subr/nls.c Sat Nov 24 20:29:11 2012 @@ -121,10 +121,12 @@ svn_nls_init(void) #else /* ! WIN32 */ bindtextdomain(PACKAGE_NAME, SVN_LOCALE_DIR); } +#endif /* WIN32 */ + #ifdef HAVE_BIND_TEXTDOMAIN_CODESET bind_textdomain_codeset(PACKAGE_NAME, "UTF-8"); #endif /* HAVE_BIND_TEXTDOMAIN_CODESET */ -#endif /* WIN32 */ + #endif /* ENABLE_NLS */ return err; Modified: subversion/branches/compressed-pristines/subversion/libsvn_subr/opt.c URL: http://svn.apache.org/viewvc/subversion/branches/compressed-pristines/subversion/libsvn_subr/opt.c?rev=1413258&r1=1413257&r2=1413258&view=diff ============================================================================== --- subversion/branches/compressed-pristines/subversion/libsvn_subr/opt.c (original) +++ subversion/branches/compressed-pristines/subversion/libsvn_subr/opt.c Sat Nov 24 20:29:11 2012 @@ -49,7 +49,6 @@ #include "private/svn_opt_private.h" #include "opt.h" -#include "sysinfo.h" #include "svn_private_config.h" @@ -1102,9 +1101,11 @@ svn_opt__arg_canonicalize_path(const cha return SVN_NO_ERROR; } + svn_error_t * svn_opt__print_version_info(const char *pgm_name, const char *footer, + const svn_version_extended_t *info, svn_boolean_t quiet, svn_boolean_t verbose, apr_pool_t *pool) @@ -1114,16 +1115,11 @@ svn_opt__print_version_info(const char * SVN_ERR(svn_cmdline_printf(pool, _("%s, version %s\n" " compiled %s, %s on %s\n\n"), - pgm_name, SVN_VERSION, __DATE__, __TIME__, - SVN_BUILD_HOST)); - SVN_ERR(svn_cmdline_fputs( - _("Copyright (C) 2012 The Apache Software Foundation.\n" - "This software consists of contributions made by many " - "people; see the NOTICE\n" - "file for more information.\n" - "Subversion is open source software, see " - "http://subversion.apache.org/\n\n";), - stdout, pool)); + pgm_name, SVN_VERSION, + svn_version_ext_build_date(info), + svn_version_ext_build_time(info), + svn_version_ext_build_host(info))); + SVN_ERR(svn_cmdline_printf(pool, "%s\n", svn_version_ext_copyright(info))); if (footer) { @@ -1132,30 +1128,66 @@ svn_opt__print_version_info(const char * if (verbose) { - const char *const host = svn_sysinfo__canonical_host(pool); - const char *const relname = svn_sysinfo__release_name(pool); - const char *const dlibs = svn_sysinfo__loaded_libs(pool); + const apr_array_header_t *libs; SVN_ERR(svn_cmdline_fputs(_("System information:\n\n"), stdout, pool)); - if (relname) - SVN_ERR(svn_cmdline_printf(pool, _("* running on %s\n" - " - %s\n"), - host, relname)); - else - SVN_ERR(svn_cmdline_printf(pool, _("* running on %s\n"), host)); + SVN_ERR(svn_cmdline_printf(pool, _("* running on %s\n"), + svn_version_ext_runtime_host(info))); + if (svn_version_ext_runtime_osname(info)) + { + SVN_ERR(svn_cmdline_printf(pool, _(" - %s\n"), + svn_version_ext_runtime_osname(info))); + } - if (dlibs) + libs = svn_version_ext_linked_libs(info); + if (libs && libs->nelts) { + const svn_version_ext_linked_lib_t *lib; + int i; + + SVN_ERR(svn_cmdline_fputs(_("* linked dependencies:\n"), + stdout, pool)); + for (i = 0; i < libs->nelts; ++i) + { + lib = &APR_ARRAY_IDX(libs, i, svn_version_ext_linked_lib_t); + if (lib->runtime_version) + SVN_ERR(svn_cmdline_printf(pool, + " - %s %s (compiled with %s)\n", + lib->name, + lib->runtime_version, + lib->compiled_version)); + else + SVN_ERR(svn_cmdline_printf(pool, + " - %s %s (static)\n", + lib->name, + lib->compiled_version)); + } + } + + libs = svn_version_ext_loaded_libs(info); + if (libs && libs->nelts) + { + const svn_version_ext_loaded_lib_t *lib; + int i; + SVN_ERR(svn_cmdline_fputs(_("* loaded shared libraries:\n"), stdout, pool)); - SVN_ERR(svn_cmdline_fputs(dlibs, stdout, pool)); + for (i = 0; i < libs->nelts; ++i) + { + lib = &APR_ARRAY_IDX(libs, i, svn_version_ext_loaded_lib_t); + if (lib->version) + SVN_ERR(svn_cmdline_printf(pool, + " - %s (%s)\n", + lib->name, lib->version)); + else + SVN_ERR(svn_cmdline_printf(pool, " - %s\n", lib->name)); + } } } return SVN_NO_ERROR; } - svn_error_t * svn_opt_print_help4(apr_getopt_t *os, const char *pgm_name, @@ -1187,8 +1219,11 @@ svn_opt_print_help4(apr_getopt_t *os, } } else if (print_version) /* just --version */ - SVN_ERR(svn_opt__print_version_info(pgm_name, version_footer, - quiet, verbose, pool)); + { + SVN_ERR(svn_opt__print_version_info(pgm_name, version_footer, + svn_version_extended(verbose, pool), + quiet, verbose, pool)); + } else if (os && !targets->nelts) /* `-h', `--help', or `help' */ svn_opt_print_generic_help2(header, cmd_table, Modified: subversion/branches/compressed-pristines/subversion/libsvn_subr/opt.h URL: http://svn.apache.org/viewvc/subversion/branches/compressed-pristines/subversion/libsvn_subr/opt.h?rev=1413258&r1=1413257&r2=1413258&view=diff ============================================================================== --- subversion/branches/compressed-pristines/subversion/libsvn_subr/opt.h (original) +++ subversion/branches/compressed-pristines/subversion/libsvn_subr/opt.h Sat Nov 24 20:29:11 2012 @@ -24,15 +24,17 @@ #ifndef SVN_LIBSVN_SUBR_OPT_H #define SVN_LIBSVN_SUBR_OPT_H +#include "svn_version.h" #include "svn_opt.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ -/* Print version info for PGM_NAME. If QUIET is true, print in - * brief. Else if QUIET is not true, print the version more - * verbosely, and if FOOTER is non-null, print it following the + +/* Print version version info for PGM_NAME to the console. If QUIET is + * true, print in brief. Else if QUIET is not true, print the version + * more verbosely, and if FOOTER is non-null, print it following the * version information. If VERBOSE is true, print running system info. * * Use POOL for temporary allocations. @@ -40,6 +42,7 @@ extern "C" { svn_error_t * svn_opt__print_version_info(const char *pgm_name, const char *footer, + const svn_version_extended_t *info, svn_boolean_t quiet, svn_boolean_t verbose, apr_pool_t *pool); Modified: subversion/branches/compressed-pristines/subversion/libsvn_subr/path.c URL: http://svn.apache.org/viewvc/subversion/branches/compressed-pristines/subversion/libsvn_subr/path.c?rev=1413258&r1=1413257&r2=1413258&view=diff ============================================================================== --- subversion/branches/compressed-pristines/subversion/libsvn_subr/path.c (original) +++ subversion/branches/compressed-pristines/subversion/libsvn_subr/path.c Sat Nov 24 20:29:11 2012 @@ -1082,7 +1082,7 @@ svn_path_url_add_component2(const char * /* = svn_path_uri_encode() but without always copying */ component = uri_escape(component, svn_uri__char_validity, pool); - return svn_path_join(url, component, pool); + return svn_path_join_internal(url, component, pool); } svn_error_t * @@ -1100,7 +1100,7 @@ svn_path_get_absolute(const char **pabso } - +#if !defined(WIN32) && !defined(DARWIN) /** Get APR's internal path encoding. */ static svn_error_t * get_path_encoding(svn_boolean_t *path_is_utf8, apr_pool_t *pool) @@ -1119,6 +1119,7 @@ get_path_encoding(svn_boolean_t *path_is *path_is_utf8 = (encoding_style == APR_FILEPATH_ENCODING_UTF8); return SVN_NO_ERROR; } +#endif svn_error_t * Added: subversion/branches/compressed-pristines/subversion/libsvn_subr/pseudo_md5.c URL: http://svn.apache.org/viewvc/subversion/branches/compressed-pristines/subversion/libsvn_subr/pseudo_md5.c?rev=1413258&view=auto ============================================================================== --- subversion/branches/compressed-pristines/subversion/libsvn_subr/pseudo_md5.c (added) +++ subversion/branches/compressed-pristines/subversion/libsvn_subr/pseudo_md5.c Sat Nov 24 20:29:11 2012 @@ -0,0 +1,422 @@ +/* + * This is work is derived from material Copyright RSA Data Security, Inc. + * + * The RSA copyright statement and Licence for that original material is + * included below. This is followed by the Apache copyright statement and + * licence for the modifications made to that material. + */ + +/* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm + */ + +/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All + rights reserved. + + License to copy and use this software is granted provided that it + is identified as the "RSA Data Security, Inc. MD5 Message-Digest + Algorithm" in all material mentioning or referencing this software + or this function. + + License is also granted to make and use derivative works provided + that such works are identified as "derived from the RSA Data + Security, Inc. MD5 Message-Digest Algorithm" in all material + mentioning or referencing the derived work. + + RSA Data Security, Inc. makes no representations concerning either + the merchantability of this software or the suitability of this + software for any particular purpose. It is provided "as is" + without express or implied warranty of any kind. + + These notices must be retained in any copies of any part of this + documentation and/or software. + */ + +/* 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. + */ + +/* + * The apr_md5_encode() routine uses much code obtained from the FreeBSD 3.0 + * MD5 crypt() function, which is licenced as follows: + * ---------------------------------------------------------------------------- + * "THE BEER-WARE LICENSE" (Revision 42): + * <[email protected]> wrote this file. As long as you retain this notice you + * can do whatever you want with this stuff. If we meet some day, and you think + * this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp + * ---------------------------------------------------------------------------- + */ + +/* + * pseudo_md5.c: md5-esque hash sum calculation for short data blocks. + * Code taken and adapted from the APR (see licenses above). + */ +#include "private/svn_pseudo_md5.h" + +/* Constants for MD5 calculation. + */ + +#define S11 7 +#define S12 12 +#define S13 17 +#define S14 22 +#define S21 5 +#define S22 9 +#define S23 14 +#define S24 20 +#define S31 4 +#define S32 11 +#define S33 16 +#define S34 23 +#define S41 6 +#define S42 10 +#define S43 15 +#define S44 21 + +/* F, G, H and I are basic MD5 functions. + */ +#define F(x, y, z) (((x) & (y)) | ((~x) & (z))) +#define G(x, y, z) (((x) & (z)) | ((y) & (~z))) +#define H(x, y, z) ((x) ^ (y) ^ (z)) +#define I(x, y, z) ((y) ^ ((x) | (~z))) + +/* ROTATE_LEFT rotates x left n bits. + */ +#if defined(_MSC_VER) && _MSC_VER >= 1310 +#pragma intrinsic(_rotl) +#define ROTATE_LEFT(x, n) (_rotl(x,n)) +#else +#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n)))) +#endif + +/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4. + * Rotation is separate from addition to prevent recomputation. + */ +#define FF(a, b, c, d, x, s, ac) { \ + (a) += F ((b), (c), (d)) + (x) + (apr_uint32_t)(ac); \ + (a) = ROTATE_LEFT ((a), (s)); \ + (a) += (b); \ + } +#define GG(a, b, c, d, x, s, ac) { \ + (a) += G ((b), (c), (d)) + (x) + (apr_uint32_t)(ac); \ + (a) = ROTATE_LEFT ((a), (s)); \ + (a) += (b); \ + } +#define HH(a, b, c, d, x, s, ac) { \ + (a) += H ((b), (c), (d)) + (x) + (apr_uint32_t)(ac); \ + (a) = ROTATE_LEFT ((a), (s)); \ + (a) += (b); \ + } +#define II(a, b, c, d, x, s, ac) { \ + (a) += I ((b), (c), (d)) + (x) + (apr_uint32_t)(ac); \ + (a) = ROTATE_LEFT ((a), (s)); \ + (a) += (b); \ + } + +/* The idea of the functions below is as follows: + * + * - The core MD5 algorithm does not assume that the "important" data + * is at the begin of the encryption block, followed by e.g. 0. + * Instead, all bits are equally relevant. + * + * - If some bytes in the input are known to be 0, we may hard-code them. + * With the previous property, it is safe to move them to the upper end + * of the encryption block to maximize the number of steps that can be + * pre-calculated. + * + * - Variable-length streams will use the upper 8 byte of the last + * encryption block to store the stream length in bits (to make 0, 00, + * 000, ... etc. produce different hash sums). + * + * - We will hash at most 63 bytes, i.e. 504 bits. In the standard stream + * implementation, the upper 6 bytes of the last encryption block would + * be 0. We will put at least one non-NULL value in the last 4 bytes. + * Therefore, our input will always be different to a standard MD5 stream + * implementation in either block count, content or both. + * + * - Our length indicator also varies with the number bytes in the input. + * Hence, different pseudo-MD5 input length produces different output + * (with "cryptographic probability") even if the content is all 0 or + * otherwise identical. + * + * - Collisions between pseudo-MD5 and pseudo-MD5 as well as pseudo-MD5 + * and standard MD5 are as likely as any other MD5 collision. + */ + +void svn__pseudo_md5_15(apr_uint32_t digest[4], + const apr_uint32_t x[4]) +{ + apr_uint32_t a = 0x67452301; + apr_uint32_t b = 0xefcdab89; + apr_uint32_t c = 0x98badcfe; + apr_uint32_t d = 0x10325476; + + /* make sure byte 63 gets the marker independently of BE / LE */ + apr_uint32_t x3n = x[3] ^ 0xffffffff; + + /* Round 1 */ + FF(a, b, c, d, 0, S11, 0xd76aa478); /* 1 */ + FF(d, a, b, c, 0, S12, 0xe8c7b756); /* 2 */ + FF(c, d, a, b, 0, S13, 0x242070db); /* 3 */ + FF(b, c, d, a, 0, S14, 0xc1bdceee); /* 4 */ + FF(a, b, c, d, 0, S11, 0xf57c0faf); /* 5 */ + FF(d, a, b, c, 0, S12, 0x4787c62a); /* 6 */ + FF(c, d, a, b, 0, S13, 0xa8304613); /* 7 */ + FF(b, c, d, a, 0, S14, 0xfd469501); /* 8 */ + FF(a, b, c, d, 0, S11, 0x698098d8); /* 9 */ + FF(d, a, b, c, 0, S12, 0x8b44f7af); /* 10 */ + FF(c, d, a, b, 0, S13, 0xffff5bb1); /* 11 */ + FF(b, c, d, a, 0, S14, 0x895cd7be); /* 12 */ + FF(a, b, c, d, x[0], S11, 0x6b901122); /* 13 */ + FF(d, a, b, c, x[1], S12, 0xfd987193); /* 14 */ + FF(c, d, a, b, x[2], S13, 0xa679438e); /* 15 */ + FF(b, c, d, a, x3n, S14, 0x49b40821); /* 16 */ + + /* Round 2 */ + GG(a, b, c, d, 0, S21, 0xf61e2562); /* 17 */ + GG(d, a, b, c, 0, S22, 0xc040b340); /* 18 */ + GG(c, d, a, b, 0, S23, 0x265e5a51); /* 19 */ + GG(b, c, d, a, 0, S24, 0xe9b6c7aa); /* 20 */ + GG(a, b, c, d, 0, S21, 0xd62f105d); /* 21 */ + GG(d, a, b, c, 0, S22, 0x2441453); /* 22 */ + GG(c, d, a, b, x3n, S23, 0xd8a1e681); /* 23 */ + GG(b, c, d, a, 0, S24, 0xe7d3fbc8); /* 24 */ + GG(a, b, c, d, 0, S21, 0x21e1cde6); /* 25 */ + GG(d, a, b, c, x[2], S22, 0xc33707d6); /* 26 */ + GG(c, d, a, b, 0, S23, 0xf4d50d87); /* 27 */ + GG(b, c, d, a, 0, S24, 0x455a14ed); /* 28 */ + GG(a, b, c, d, x[1], S21, 0xa9e3e905); /* 29 */ + GG(d, a, b, c, 0, S22, 0xfcefa3f8); /* 30 */ + GG(c, d, a, b, 0, S23, 0x676f02d9); /* 31 */ + GG(b, c, d, a, x[0], S24, 0x8d2a4c8a); /* 32 */ + + /* Round 3 */ + HH(a, b, c, d, 0, S31, 0xfffa3942); /* 33 */ + HH(d, a, b, c, 0, S32, 0x8771f681); /* 34 */ + HH(c, d, a, b, 0, S33, 0x6d9d6122); /* 35 */ + HH(b, c, d, a, x[2], S34, 0xfde5380c); /* 36 */ + HH(a, b, c, d, 0, S31, 0xa4beea44); /* 37 */ + HH(d, a, b, c, 0, S32, 0x4bdecfa9); /* 38 */ + HH(c, d, a, b, 0, S33, 0xf6bb4b60); /* 39 */ + HH(b, c, d, a, 0, S34, 0xbebfbc70); /* 40 */ + HH(a, b, c, d, x[1], S31, 0x289b7ec6); /* 41 */ + HH(d, a, b, c, 0, S32, 0xeaa127fa); /* 42 */ + HH(c, d, a, b, 0, S33, 0xd4ef3085); /* 43 */ + HH(b, c, d, a, 0, S34, 0x4881d05); /* 44 */ + HH(a, b, c, d, 0, S31, 0xd9d4d039); /* 45 */ + HH(d, a, b, c, x[0], S32, 0xe6db99e5); /* 46 */ + HH(c, d, a, b, x3n, S33, 0x1fa27cf8); /* 47 */ + HH(b, c, d, a, 0, S34, 0xc4ac5665); /* 48 */ + + /* Round 4 */ + II(a, b, c, d, 0, S41, 0xf4292244); /* 49 */ + II(d, a, b, c, 0, S42, 0x432aff97); /* 50 */ + II(c, d, a, b, x[2], S43, 0xab9423a7); /* 51 */ + II(b, c, d, a, 0, S44, 0xfc93a039); /* 52 */ + II(a, b, c, d, x[0], S41, 0x655b59c3); /* 53 */ + II(d, a, b, c, 0, S42, 0x8f0ccc92); /* 54 */ + II(c, d, a, b, 0, S43, 0xffeff47d); /* 55 */ + II(b, c, d, a, 0, S44, 0x85845dd1); /* 56 */ + II(a, b, c, d, 0, S41, 0x6fa87e4f); /* 57 */ + II(d, a, b, c, x3n, S42, 0xfe2ce6e0); /* 58 */ + II(c, d, a, b, 0, S43, 0xa3014314); /* 59 */ + II(b, c, d, a, x[1], S44, 0x4e0811a1); /* 60 */ + II(a, b, c, d, 0, S41, 0xf7537e82); /* 61 */ + II(d, a, b, c, 0, S42, 0xbd3af235); /* 62 */ + II(c, d, a, b, 0, S43, 0x2ad7d2bb); /* 63 */ + II(b, c, d, a, 0, S44, 0xeb86d391); /* 64 */ + + digest[0] = a; + digest[1] = b; + digest[2] = c; + digest[3] = d; +} + +void svn__pseudo_md5_31(apr_uint32_t digest[4], + const apr_uint32_t x[8]) +{ + apr_uint32_t a = 0x67452301; + apr_uint32_t b = 0xefcdab89; + apr_uint32_t c = 0x98badcfe; + apr_uint32_t d = 0x10325476; + + /* make sure byte 63 gets the marker independently of BE / LE */ + apr_uint32_t x7n = x[7] ^ 0xfefefefe; + + /* Round 1 */ + FF(a, b, c, d, 0, S11, 0xd76aa478); /* 1 */ + FF(d, a, b, c, 0, S12, 0xe8c7b756); /* 2 */ + FF(c, d, a, b, 0, S13, 0x242070db); /* 3 */ + FF(b, c, d, a, 0, S14, 0xc1bdceee); /* 4 */ + FF(a, b, c, d, 0, S11, 0xf57c0faf); /* 5 */ + FF(d, a, b, c, 0, S12, 0x4787c62a); /* 6 */ + FF(c, d, a, b, 0, S13, 0xa8304613); /* 7 */ + FF(b, c, d, a, 0, S14, 0xfd469501); /* 8 */ + FF(a, b, c, d, x[0], S11, 0x698098d8); /* 9 */ + FF(d, a, b, c, x[1], S12, 0x8b44f7af); /* 10 */ + FF(c, d, a, b, x[2], S13, 0xffff5bb1); /* 11 */ + FF(b, c, d, a, x[3], S14, 0x895cd7be); /* 12 */ + FF(a, b, c, d, x[4], S11, 0x6b901122); /* 13 */ + FF(d, a, b, c, x[5], S12, 0xfd987193); /* 14 */ + FF(c, d, a, b, x[6], S13, 0xa679438e); /* 15 */ + FF(b, c, d, a, x7n, S14, 0x49b40821); /* 16 */ + + /* Round 2 */ + GG(a, b, c, d, 0, S21, 0xf61e2562); /* 17 */ + GG(d, a, b, c, 0, S22, 0xc040b340); /* 18 */ + GG(c, d, a, b, x[3], S23, 0x265e5a51); /* 19 */ + GG(b, c, d, a, 0, S24, 0xe9b6c7aa); /* 20 */ + GG(a, b, c, d, 0, S21, 0xd62f105d); /* 21 */ + GG(d, a, b, c, x[2], S22, 0x2441453); /* 22 */ + GG(c, d, a, b, x7n, S23, 0xd8a1e681); /* 23 */ + GG(b, c, d, a, 0, S24, 0xe7d3fbc8); /* 24 */ + GG(a, b, c, d, x[1], S21, 0x21e1cde6); /* 25 */ + GG(d, a, b, c, x[6], S22, 0xc33707d6); /* 26 */ + GG(c, d, a, b, 0, S23, 0xf4d50d87); /* 27 */ + GG(b, c, d, a, x[0], S24, 0x455a14ed); /* 28 */ + GG(a, b, c, d, x[5], S21, 0xa9e3e905); /* 29 */ + GG(d, a, b, c, 0, S22, 0xfcefa3f8); /* 30 */ + GG(c, d, a, b, 0, S23, 0x676f02d9); /* 31 */ + GG(b, c, d, a, x[4], S24, 0x8d2a4c8a); /* 32 */ + + /* Round 3 */ + HH(a, b, c, d, 0, S31, 0xfffa3942); /* 33 */ + HH(d, a, b, c, x[0], S32, 0x8771f681); /* 34 */ + HH(c, d, a, b, x[3], S33, 0x6d9d6122); /* 35 */ + HH(b, c, d, a, x[6], S34, 0xfde5380c); /* 36 */ + HH(a, b, c, d, 0, S31, 0xa4beea44); /* 37 */ + HH(d, a, b, c, 0, S32, 0x4bdecfa9); /* 38 */ + HH(c, d, a, b, 0, S33, 0xf6bb4b60); /* 39 */ + HH(b, c, d, a, x[2], S34, 0xbebfbc70); /* 40 */ + HH(a, b, c, d, x[5], S31, 0x289b7ec6); /* 41 */ + HH(d, a, b, c, 0, S32, 0xeaa127fa); /* 42 */ + HH(c, d, a, b, 0, S33, 0xd4ef3085); /* 43 */ + HH(b, c, d, a, 0, S34, 0x4881d05); /* 44 */ + HH(a, b, c, d, x[1], S31, 0xd9d4d039); /* 45 */ + HH(d, a, b, c, x[4], S32, 0xe6db99e5); /* 46 */ + HH(c, d, a, b, x7n, S33, 0x1fa27cf8); /* 47 */ + HH(b, c, d, a, 0, S34, 0xc4ac5665); /* 48 */ + + /* Round 4 */ + II(a, b, c, d, 0, S41, 0xf4292244); /* 49 */ + II(d, a, b, c, 0, S42, 0x432aff97); /* 50 */ + II(c, d, a, b, x[6], S43, 0xab9423a7); /* 51 */ + II(b, c, d, a, 0, S44, 0xfc93a039); /* 52 */ + II(a, b, c, d, x[4], S41, 0x655b59c3); /* 53 */ + II(d, a, b, c, 0, S42, 0x8f0ccc92); /* 54 */ + II(c, d, a, b, x[2], S43, 0xffeff47d); /* 55 */ + II(b, c, d, a, 0, S44, 0x85845dd1); /* 56 */ + II(a, b, c, d, x[0], S41, 0x6fa87e4f); /* 57 */ + II(d, a, b, c, x7n, S42, 0xfe2ce6e0); /* 58 */ + II(c, d, a, b, 0, S43, 0xa3014314); /* 59 */ + II(b, c, d, a, x[5], S44, 0x4e0811a1); /* 60 */ + II(a, b, c, d, 0, S41, 0xf7537e82); /* 61 */ + II(d, a, b, c, x[3], S42, 0xbd3af235); /* 62 */ + II(c, d, a, b, 0, S43, 0x2ad7d2bb); /* 63 */ + II(b, c, d, a, x[1], S44, 0xeb86d391); /* 64 */ + + digest[0] = a; + digest[1] = b; + digest[2] = c; + digest[3] = d; +} + +void svn__pseudo_md5_63(apr_uint32_t digest[4], + const apr_uint32_t x[16]) +{ + apr_uint32_t a = 0x67452301; + apr_uint32_t b = 0xefcdab89; + apr_uint32_t c = 0x98badcfe; + apr_uint32_t d = 0x10325476; + + /* make sure byte 63 gets the marker independently of BE / LE */ + apr_uint32_t x15n = x[15] ^ 0xfcfcfcfc; + + /* Round 1 */ + FF(a, b, c, d, x[0], S11, 0xd76aa478); /* 1 */ + FF(d, a, b, c, x[1], S12, 0xe8c7b756); /* 2 */ + FF(c, d, a, b, x[2], S13, 0x242070db); /* 3 */ + FF(b, c, d, a, x[3], S14, 0xc1bdceee); /* 4 */ + FF(a, b, c, d, x[4], S11, 0xf57c0faf); /* 5 */ + FF(d, a, b, c, x[5], S12, 0x4787c62a); /* 6 */ + FF(c, d, a, b, x[6], S13, 0xa8304613); /* 7 */ + FF(b, c, d, a, x[7], S14, 0xfd469501); /* 8 */ + FF(a, b, c, d, x[8], S11, 0x698098d8); /* 9 */ + FF(d, a, b, c, x[9], S12, 0x8b44f7af); /* 10 */ + FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */ + FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */ + FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */ + FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */ + FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */ + FF(b, c, d, a, x15n, S14, 0x49b40821); /* 16 */ + + /* Round 2 */ + GG(a, b, c, d, x[1], S21, 0xf61e2562); /* 17 */ + GG(d, a, b, c, x[6], S22, 0xc040b340); /* 18 */ + GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */ + GG(b, c, d, a, x[0], S24, 0xe9b6c7aa); /* 20 */ + GG(a, b, c, d, x[5], S21, 0xd62f105d); /* 21 */ + GG(d, a, b, c, x[10], S22, 0x2441453); /* 22 */ + GG(c, d, a, b, x15n, S23, 0xd8a1e681); /* 23 */ + GG(b, c, d, a, x[4], S24, 0xe7d3fbc8); /* 24 */ + GG(a, b, c, d, x[9], S21, 0x21e1cde6); /* 25 */ + GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */ + GG(c, d, a, b, x[3], S23, 0xf4d50d87); /* 27 */ + GG(b, c, d, a, x[8], S24, 0x455a14ed); /* 28 */ + GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */ + GG(d, a, b, c, x[2], S22, 0xfcefa3f8); /* 30 */ + GG(c, d, a, b, x[7], S23, 0x676f02d9); /* 31 */ + GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */ + + /* Round 3 */ + HH(a, b, c, d, x[5], S31, 0xfffa3942); /* 33 */ + HH(d, a, b, c, x[8], S32, 0x8771f681); /* 34 */ + HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */ + HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */ + HH(a, b, c, d, x[1], S31, 0xa4beea44); /* 37 */ + HH(d, a, b, c, x[4], S32, 0x4bdecfa9); /* 38 */ + HH(c, d, a, b, x[7], S33, 0xf6bb4b60); /* 39 */ + HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */ + HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */ + HH(d, a, b, c, x[0], S32, 0xeaa127fa); /* 42 */ + HH(c, d, a, b, x[3], S33, 0xd4ef3085); /* 43 */ + HH(b, c, d, a, x[6], S34, 0x4881d05); /* 44 */ + HH(a, b, c, d, x[9], S31, 0xd9d4d039); /* 45 */ + HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */ + HH(c, d, a, b, x15n, S33, 0x1fa27cf8); /* 47 */ + HH(b, c, d, a, x[2], S34, 0xc4ac5665); /* 48 */ + + /* Round 4 */ + II(a, b, c, d, x[0], S41, 0xf4292244); /* 49 */ + II(d, a, b, c, x[7], S42, 0x432aff97); /* 50 */ + II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */ + II(b, c, d, a, x[5], S44, 0xfc93a039); /* 52 */ + II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */ + II(d, a, b, c, x[3], S42, 0x8f0ccc92); /* 54 */ + II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */ + II(b, c, d, a, x[1], S44, 0x85845dd1); /* 56 */ + II(a, b, c, d, x[8], S41, 0x6fa87e4f); /* 57 */ + II(d, a, b, c, x15n, S42, 0xfe2ce6e0); /* 58 */ + II(c, d, a, b, x[6], S43, 0xa3014314); /* 59 */ + II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */ + II(a, b, c, d, x[4], S41, 0xf7537e82); /* 61 */ + II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */ + II(c, d, a, b, x[2], S43, 0x2ad7d2bb); /* 63 */ + II(b, c, d, a, x[9], S44, 0xeb86d391); /* 64 */ + + digest[0] = a; + digest[1] = b; + digest[2] = c; + digest[3] = d; +} Modified: subversion/branches/compressed-pristines/subversion/libsvn_subr/simple_providers.c URL: http://svn.apache.org/viewvc/subversion/branches/compressed-pristines/subversion/libsvn_subr/simple_providers.c?rev=1413258&r1=1413257&r2=1413258&view=diff ============================================================================== --- subversion/branches/compressed-pristines/subversion/libsvn_subr/simple_providers.c (original) +++ subversion/branches/compressed-pristines/subversion/libsvn_subr/simple_providers.c Sat Nov 24 20:29:11 2012 @@ -475,6 +475,10 @@ svn_auth__simple_creds_cache_set(svn_boo /* Save credentials to disk. */ err = svn_config_write_auth_data(creds_hash, SVN_AUTH_CRED_SIMPLE, realmstring, config_dir, pool); + if (err) + *saved = FALSE; + + /* ### return error? */ svn_error_clear(err); return SVN_NO_ERROR; Modified: subversion/branches/compressed-pristines/subversion/libsvn_subr/skel.c URL: http://svn.apache.org/viewvc/subversion/branches/compressed-pristines/subversion/libsvn_subr/skel.c?rev=1413258&r1=1413257&r2=1413258&view=diff ============================================================================== --- subversion/branches/compressed-pristines/subversion/libsvn_subr/skel.c (original) +++ subversion/branches/compressed-pristines/subversion/libsvn_subr/skel.c Sat Nov 24 20:29:11 2012 @@ -23,6 +23,8 @@ #include <string.h> #include "svn_string.h" #include "svn_error.h" +#include "svn_props.h" +#include "svn_pools.h" #include "private/svn_skel.h" #include "private/svn_string_private.h" @@ -167,6 +169,35 @@ is_valid_proplist_skel(const svn_skel_t return FALSE; } +static svn_boolean_t +is_valid_iproplist_skel(const svn_skel_t *skel) +{ + int len = svn_skel__list_length(skel); + + if ((len >= 0) && (len & 1) == 0) + { + svn_skel_t *elt; + + for (elt = skel->children; elt; elt = elt->next) + { + if (!elt->is_atom) + return FALSE; + + if (elt->next == NULL) + return FALSE; + + elt = elt->next; + + if (! is_valid_proplist_skel(elt)) + return FALSE; + } + + return TRUE; + } + + return FALSE; +} + static svn_skel_t *parse(const char *data, apr_size_t len, apr_pool_t *pool); @@ -689,6 +720,34 @@ svn_skel__parse_proplist(apr_hash_t **pr return SVN_NO_ERROR; } +svn_error_t * +svn_skel__parse_iprops(apr_array_header_t **iprops, + const svn_skel_t *skel, + apr_pool_t *result_pool) +{ + svn_skel_t *elt; + + /* Validate the skel. */ + if (! is_valid_iproplist_skel(skel)) + return skel_err("iprops"); + + /* Create the returned structure */ + *iprops = apr_array_make(result_pool, 1, + sizeof(svn_prop_inherited_item_t *)); + + for (elt = skel->children; elt; elt = elt->next->next) + { + svn_prop_inherited_item_t *new_iprop = apr_palloc(result_pool, + sizeof(*new_iprop)); + svn_string_t *repos_parent = svn_string_ncreate(elt->data, elt->len, + result_pool); + SVN_ERR(svn_skel__parse_proplist(&(new_iprop->prop_hash), elt->next, + result_pool)); + new_iprop->path_or_url = repos_parent->data; + APR_ARRAY_PUSH(*iprops, svn_prop_inherited_item_t *) = new_iprop; + } + return SVN_NO_ERROR; +} svn_error_t * svn_skel__parse_prop(svn_string_t **propval, @@ -760,3 +819,65 @@ svn_skel__unparse_proplist(svn_skel_t ** *skel_p = skel; return SVN_NO_ERROR; } + +svn_error_t * +svn_skel__unparse_iproplist(svn_skel_t **skel_p, + const apr_array_header_t *inherited_props, + apr_pool_t *result_pool) +{ + svn_skel_t *skel = svn_skel__make_empty_list(result_pool); + + /* Create the skel. */ + if (inherited_props) + { + int i; + apr_hash_index_t *hi; + apr_pool_t *subpool = svn_pool_create(result_pool); + + for (i = 0; i < inherited_props->nelts; i++) + { + svn_prop_inherited_item_t *iprop = + APR_ARRAY_IDX(inherited_props, i, svn_prop_inherited_item_t *); + + svn_skel_t *skel_list = svn_skel__make_empty_list(result_pool); + svn_skel_t *skel_atom; + + svn_pool_clear(subpool); + + /* Loop over hash entries */ + for (hi = apr_hash_first(subpool, iprop->prop_hash); + hi; + hi = apr_hash_next(hi)) + { + const void *key; + void *val; + apr_ssize_t klen; + svn_string_t *value; + + apr_hash_this(hi, &key, &klen, &val); + value = val; + + /* VALUE */ + svn_skel__prepend(svn_skel__mem_atom(value->data, value->len, + result_pool), skel_list); + + /* NAME */ + svn_skel__prepend(svn_skel__mem_atom(key, klen, result_pool), + skel_list); + } + + skel_atom = svn_skel__str_atom( + apr_pstrdup(result_pool, iprop->path_or_url), result_pool); + svn_skel__append(skel, skel_atom); + svn_skel__append(skel, skel_list); + } + svn_pool_destroy(subpool); + } + + /* Validate and return the skel. */ + if (! is_valid_iproplist_skel(skel)) + return skel_err("iproplist"); + + *skel_p = skel; + return SVN_NO_ERROR; +} Modified: subversion/branches/compressed-pristines/subversion/libsvn_subr/sqlite.c URL: http://svn.apache.org/viewvc/subversion/branches/compressed-pristines/subversion/libsvn_subr/sqlite.c?rev=1413258&r1=1413257&r2=1413258&view=diff ============================================================================== --- subversion/branches/compressed-pristines/subversion/libsvn_subr/sqlite.c (original) +++ subversion/branches/compressed-pristines/subversion/libsvn_subr/sqlite.c Sat Nov 24 20:29:11 2012 @@ -45,6 +45,9 @@ #ifdef SVN_SQLITE_INLINE /* Include sqlite3 inline, making all symbols private. */ #define SQLITE_API static + #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6) + #pragma GCC diagnostic ignored "-Wunused-function" + #endif #include <sqlite3.c> #else #include <sqlite3.h> @@ -54,6 +57,20 @@ #error SQLite is too old -- version 3.7.12 is the minimum required version #endif +const char * +svn_sqlite__compiled_version(void) +{ + static const char sqlite_version[] = SQLITE_VERSION; + return sqlite_version; +} + +const char * +svn_sqlite__runtime_version(void) +{ + return sqlite3_libversion(); +} + + INTERNAL_STATEMENTS_SQL_DECLARE_STATEMENTS(internal_statements); @@ -462,6 +479,27 @@ svn_sqlite__bind_properties(svn_sqlite__ } svn_error_t * +svn_sqlite__bind_iprops(svn_sqlite__stmt_t *stmt, + int slot, + const apr_array_header_t *inherited_props, + apr_pool_t *scratch_pool) +{ + svn_skel_t *skel; + svn_stringbuf_t *properties; + + if (inherited_props == NULL) + return svn_error_trace(svn_sqlite__bind_blob(stmt, slot, NULL, 0)); + + SVN_ERR(svn_skel__unparse_iproplist(&skel, inherited_props, + scratch_pool)); + properties = svn_skel__unparse(skel, scratch_pool); + return svn_error_trace(svn_sqlite__bind_blob(stmt, + slot, + properties->data, + properties->len)); +} + +svn_error_t * svn_sqlite__bind_checksum(svn_sqlite__stmt_t *stmt, int slot, const svn_checksum_t *checksum, @@ -567,6 +605,31 @@ svn_sqlite__column_properties(apr_hash_t } svn_error_t * +svn_sqlite__column_iprops(apr_array_header_t **iprops, + svn_sqlite__stmt_t *stmt, + int column, + apr_pool_t *result_pool, + apr_pool_t *scratch_pool) +{ + apr_size_t len; + const void *val; + + /* svn_skel__parse_iprops copies everything needed to result_pool */ + val = svn_sqlite__column_blob(stmt, column, &len, NULL); + if (val == NULL) + { + *iprops = NULL; + return SVN_NO_ERROR; + } + + SVN_ERR(svn_skel__parse_iprops(iprops, + svn_skel__parse(val, len, scratch_pool), + result_pool)); + + return SVN_NO_ERROR; +} + +svn_error_t * svn_sqlite__column_checksum(const svn_checksum_t **checksum, svn_sqlite__stmt_t *stmt, int column, apr_pool_t *result_pool) Modified: subversion/branches/compressed-pristines/subversion/libsvn_subr/ssl_client_cert_pw_providers.c URL: http://svn.apache.org/viewvc/subversion/branches/compressed-pristines/subversion/libsvn_subr/ssl_client_cert_pw_providers.c?rev=1413258&r1=1413257&r2=1413258&view=diff ============================================================================== --- subversion/branches/compressed-pristines/subversion/libsvn_subr/ssl_client_cert_pw_providers.c (original) +++ subversion/branches/compressed-pristines/subversion/libsvn_subr/ssl_client_cert_pw_providers.c Sat Nov 24 20:29:11 2012 @@ -82,7 +82,7 @@ svn_auth__ssl_client_cert_pw_get(svn_boo return SVN_NO_ERROR; } *done = FALSE; - return FALSE; + return SVN_NO_ERROR; } /* This implements the svn_auth__password_set_t interface. Modified: subversion/branches/compressed-pristines/subversion/libsvn_subr/string.c URL: http://svn.apache.org/viewvc/subversion/branches/compressed-pristines/subversion/libsvn_subr/string.c?rev=1413258&r1=1413257&r2=1413258&view=diff ============================================================================== --- subversion/branches/compressed-pristines/subversion/libsvn_subr/string.c (original) +++ subversion/branches/compressed-pristines/subversion/libsvn_subr/string.c Sat Nov 24 20:29:11 2012 @@ -578,6 +578,80 @@ svn_stringbuf_appendcstr(svn_stringbuf_t svn_stringbuf_appendbytes(targetstr, cstr, strlen(cstr)); } +void +svn_stringbuf_insert(svn_stringbuf_t *str, + apr_size_t pos, + const char *bytes, + apr_size_t count) +{ + if (bytes + count > str->data && bytes < str->data + str->blocksize) + { + /* special case: BYTES overlaps with this string -> copy the source */ + const char *temp = apr_pstrndup(str->pool, bytes, count); + svn_stringbuf_insert(str, pos, temp, count); + } + else + { + if (pos > str->len) + pos = str->len; + + svn_stringbuf_ensure(str, str->len + count); + memmove(str->data + pos + count, str->data + pos, str->len - pos + 1); + memcpy(str->data + pos, bytes, count); + + str->len += count; + } +} + +void +svn_stringbuf_remove(svn_stringbuf_t *str, + apr_size_t pos, + apr_size_t count) +{ + if (pos > str->len) + pos = str->len; + if (pos + count > str->len) + count = str->len - pos; + + memmove(str->data + pos, str->data + pos + count, str->len - pos - count + 1); + str->len -= count; +} + +void +svn_stringbuf_replace(svn_stringbuf_t *str, + apr_size_t pos, + apr_size_t old_count, + const char *bytes, + apr_size_t new_count) +{ + if (bytes + new_count > str->data && bytes < str->data + str->blocksize) + { + /* special case: BYTES overlaps with this string -> copy the source */ + const char *temp = apr_pstrndup(str->pool, bytes, new_count); + svn_stringbuf_replace(str, pos, old_count, temp, new_count); + } + else + { + if (pos > str->len) + pos = str->len; + if (pos + old_count > str->len) + old_count = str->len - pos; + + if (old_count < new_count) + { + apr_size_t delta = new_count - old_count; + svn_stringbuf_ensure(str, str->len + delta); + } + + if (old_count != new_count) + memmove(str->data + pos + new_count, str->data + pos + old_count, + str->len - pos - old_count + 1); + + memcpy(str->data + pos, bytes, new_count); + str->len += new_count - old_count; + } +} + svn_stringbuf_t * svn_stringbuf_dup(const svn_stringbuf_t *original_string, apr_pool_t *pool) @@ -989,7 +1063,7 @@ svn__ui64toa(char * dest, apr_uint64_t n target -= 8; } - /* Now, the number fits into 32 bits, but is larger than 1 */ + /* Now, the number fits into 32 bits, but may still be larger than 99 */ reduced = (apr_uint32_t)(number); while (reduced >= 100) { @@ -1019,3 +1093,44 @@ svn__i64toa(char * dest, apr_int64_t num *dest = '-'; return svn__ui64toa(dest + 1, (apr_uint64_t)(0-number)) + 1; } + +static void +ui64toa_sep(apr_uint64_t number, char seperator, char *buffer) +{ + apr_size_t length = svn__ui64toa(buffer, number); + apr_size_t i; + + for (i = length; i > 3; i -= 3) + { + memmove(&buffer[i - 2], &buffer[i - 3], length - i + 3); + buffer[i-3] = seperator; + length++; + } + + buffer[length] = 0; +} + +char * +svn__ui64toa_sep(apr_uint64_t number, char seperator, apr_pool_t *pool) +{ + char buffer[2 * SVN_INT64_BUFFER_SIZE]; + ui64toa_sep(number, seperator, buffer); + + return apr_pstrdup(pool, buffer); +} + +char * +svn__i64toa_sep(apr_int64_t number, char seperator, apr_pool_t *pool) +{ + char buffer[2 * SVN_INT64_BUFFER_SIZE]; + if (number < 0) + { + buffer[0] = '-'; + ui64toa_sep((apr_uint64_t)(-number), seperator, &buffer[1]); + } + else + ui64toa_sep((apr_uint64_t)(number), seperator, buffer); + + return apr_pstrdup(pool, buffer); +} + Modified: subversion/branches/compressed-pristines/subversion/libsvn_subr/subst.c URL: http://svn.apache.org/viewvc/subversion/branches/compressed-pristines/subversion/libsvn_subr/subst.c?rev=1413258&r1=1413257&r2=1413258&view=diff ============================================================================== --- subversion/branches/compressed-pristines/subversion/libsvn_subr/subst.c (original) +++ subversion/branches/compressed-pristines/subversion/libsvn_subr/subst.c Sat Nov 24 20:29:11 2012 @@ -1613,7 +1613,7 @@ create_special_file_from_stream(svn_stre } if (! strncmp(identifier, SVN_SUBST__SPECIAL_LINK_STR " ", - strlen(SVN_SUBST__SPECIAL_LINK_STR " "))) + sizeof(SVN_SUBST__SPECIAL_LINK_STR " ")-1)) { /* For symlinks, the type specific data is just a filesystem path that the symlink should reference. */
