/* * properties.c: stuff related to Subversion properties * * ==================================================================== * 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. * ==================================================================== */ #include #include #include #include /* for strncmp() */ #include "svn_hash.h" #include "svn_string.h" #include "svn_props.h" #include "svn_error.h" #include "svn_ctype.h" #include "private/svn_subr_private.h" /* All Subversion-specific versioned node properties * known to this client, that are applicable to both a file and a dir. */ #define SVN_PROP__NODE_COMMON_PROPS SVN_PROP_MERGEINFO, \ SVN_PROP_TEXT_TIME, \ SVN_PROP_OWNER, \ SVN_PROP_GROUP, \ SVN_PROP_UNIX_MODE, /* All Subversion-specific versioned node properties * known to this client, that are applicable to a dir only. */ #define SVN_PROP__NODE_DIR_ONLY_PROPS SVN_PROP_IGNORE, \ SVN_PROP_INHERITABLE_IGNORES, \ SVN_PROP_INHERITABLE_AUTO_PROPS, \ SVN_PROP_EXTERNALS, /* All Subversion-specific versioned node properties * known to this client, that are applicable to a file only. */ #define SVN_PROP__NODE_FILE_ONLY_PROPS SVN_PROP_MIME_TYPE, \ SVN_PROP_EOL_STYLE, \ SVN_PROP_KEYWORDS, \ SVN_PROP_EXECUTABLE, \ SVN_PROP_NEEDS_LOCK, \ SVN_PROP_SPECIAL, static const char *const known_rev_props[] = { SVN_PROP_REVISION_ALL_PROPS NULL }; static const char *const known_node_props[] = { SVN_PROP__NODE_COMMON_PROPS SVN_PROP__NODE_DIR_ONLY_PROPS SVN_PROP__NODE_FILE_ONLY_PROPS NULL }; static const char *const known_dir_props[] = { SVN_PROP__NODE_COMMON_PROPS SVN_PROP__NODE_DIR_ONLY_PROPS NULL }; static const char *const known_file_props[] = { SVN_PROP__NODE_COMMON_PROPS SVN_PROP__NODE_FILE_ONLY_PROPS NULL }; static svn_boolean_t is_known_prop(const char *prop_name, const char *const *known_props) { while (*known_props) { if (strcmp(prop_name, *known_props++) == 0) return TRUE; } return FALSE; } svn_boolean_t svn_prop_is_known_svn_rev_prop(const char *prop_name) { return is_known_prop(prop_name, known_rev_props); } svn_boolean_t svn_prop_is_known_svn_node_prop(const char *prop_name) { return is_known_prop(prop_name, known_node_props); } svn_boolean_t svn_prop_is_known_svn_file_prop(const char *prop_name) { return is_known_prop(prop_name, known_file_props); } svn_boolean_t svn_prop_is_known_svn_dir_prop(const char *prop_name) { return is_known_prop(prop_name, known_dir_props); } svn_boolean_t svn_prop_is_svn_prop(const char *prop_name) { return strncmp(prop_name, SVN_PROP_PREFIX, (sizeof(SVN_PROP_PREFIX) - 1)) == 0; } svn_boolean_t svn_prop_has_svn_prop(const apr_hash_t *props, apr_pool_t *pool) { apr_hash_index_t *hi; const void *prop_name; if (! props) return FALSE; for (hi = apr_hash_first(pool, (apr_hash_t *)props); hi; hi = apr_hash_next(hi)) { apr_hash_this(hi, &prop_name, NULL, NULL); if (svn_prop_is_svn_prop((const char *) prop_name)) return TRUE; } return FALSE; } #define SIZEOF_WC_PREFIX (sizeof(SVN_PROP_WC_PREFIX) - 1) #define SIZEOF_ENTRY_PREFIX (sizeof(SVN_PROP_ENTRY_PREFIX) - 1) svn_prop_kind_t svn_property_kind2(const char *prop_name) { if (strncmp(prop_name, SVN_PROP_WC_PREFIX, SIZEOF_WC_PREFIX) == 0) return svn_prop_wc_kind; if (strncmp(prop_name, SVN_PROP_ENTRY_PREFIX, SIZEOF_ENTRY_PREFIX) == 0) return svn_prop_entry_kind; return svn_prop_regular_kind; } /* NOTE: this function is deprecated, but we cannot move it to deprecated.c because we need the SIZEOF_*_PREFIX constant symbols defined above. */ svn_prop_kind_t svn_property_kind(int *prefix_len, const char *prop_name) { svn_prop_kind_t kind = svn_property_kind2(prop_name); if (prefix_len) { if (kind == svn_prop_wc_kind) *prefix_len = SIZEOF_WC_PREFIX; else if (kind == svn_prop_entry_kind) *prefix_len = SIZEOF_ENTRY_PREFIX; else *prefix_len = 0; } return kind; } svn_error_t * svn_categorize_props(const apr_array_header_t *proplist, apr_array_header_t **entry_props, apr_array_header_t **wc_props, apr_array_header_t **regular_props, apr_pool_t *pool) { int i; if (entry_props) *entry_props = apr_array_make(pool, 1, sizeof(svn_prop_t)); if (wc_props) *wc_props = apr_array_make(pool, 1, sizeof(svn_prop_t)); if (regular_props) *regular_props = apr_array_make(pool, 1, sizeof(svn_prop_t)); for (i = 0; i < proplist->nelts; i++) { svn_prop_t *prop, *newprop; enum svn_prop_kind kind; prop = &APR_ARRAY_IDX(proplist, i, svn_prop_t); kind = svn_property_kind2(prop->name); newprop = NULL; if (kind == svn_prop_regular_kind) { if (regular_props) newprop = apr_array_push(*regular_props); } else if (kind == svn_prop_wc_kind) { if (wc_props) newprop = apr_array_push(*wc_props); } else if (kind == svn_prop_entry_kind) { if (entry_props) newprop = apr_array_push(*entry_props); } else /* Technically this can't happen, but might as well have the code ready in case that ever changes. */ return svn_error_createf(SVN_ERR_BAD_PROP_KIND, NULL, "Bad property kind for property '%s'", prop->name); if (newprop) { newprop->name = prop->name; newprop->value = prop->value; } } return SVN_NO_ERROR; } svn_error_t * svn_prop_diffs(apr_array_header_t **propdiffs, const apr_hash_t *target_props, const apr_hash_t *source_props, apr_pool_t *pool) { apr_hash_index_t *hi; apr_array_header_t *ary = apr_array_make(pool, 1, sizeof(svn_prop_t)); /* Note: we will be storing the pointers to the keys (from the hashes) into the propdiffs array. It is acceptable for us to reference the same memory as the base/target_props hash. */ /* Loop over SOURCE_PROPS and examine each key. This will allow us to detect any `deletion' events or `set-modification' events. */ for (hi = apr_hash_first(pool, (apr_hash_t *)source_props); hi; hi = apr_hash_next(hi)) { const void *key; apr_ssize_t klen; void *val; const svn_string_t *propval1, *propval2; /* Get next property */ apr_hash_this(hi, &key, &klen, &val); propval1 = val; /* Does property name exist in TARGET_PROPS? */ propval2 = apr_hash_get((apr_hash_t *)target_props, key, klen); if (propval2 == NULL) { /* Add a delete event to the array */ svn_prop_t *p = apr_array_push(ary); p->name = key; p->value = NULL; } else if (! svn_string_compare(propval1, propval2)) { /* Add a set (modification) event to the array */ svn_prop_t *p = apr_array_push(ary); p->name = key; p->value = svn_string_dup(propval2, pool); } } /* Loop over TARGET_PROPS and examine each key. This allows us to detect `set-creation' events */ for (hi = apr_hash_first(pool, (apr_hash_t *)target_props); hi; hi = apr_hash_next(hi)) { const void *key; apr_ssize_t klen; void *val; const svn_string_t *propval; /* Get next property */ apr_hash_this(hi, &key, &klen, &val); propval = val; /* Does property name exist in SOURCE_PROPS? */ if (NULL == apr_hash_get((apr_hash_t *)source_props, key, klen)) { /* Add a set (creation) event to the array */ svn_prop_t *p = apr_array_push(ary); p->name = key; p->value = svn_string_dup(propval, pool); } } /* Done building our array of user events. */ *propdiffs = ary; return SVN_NO_ERROR; } apr_hash_t * svn_prop__patch(const apr_hash_t *original_props, const apr_array_header_t *prop_changes, apr_pool_t *pool) { apr_hash_t *props = apr_hash_copy(pool, original_props); int i; for (i = 0; i < prop_changes->nelts; i++) { const svn_prop_t *p = &APR_ARRAY_IDX(prop_changes, i, svn_prop_t); svn_hash_sets(props, p->name, p->value); } return props; } /** * Reallocate the members of PROP using POOL. */ static void svn_prop__members_dup(svn_prop_t *prop, apr_pool_t *pool) { if (prop->name) prop->name = apr_pstrdup(pool, prop->name); if (prop->value) prop->value = svn_string_dup(prop->value, pool); } svn_prop_t * svn_prop_dup(const svn_prop_t *prop, apr_pool_t *pool) { svn_prop_t *new_prop = apr_palloc(pool, sizeof(*new_prop)); *new_prop = *prop; svn_prop__members_dup(new_prop, pool); return new_prop; } apr_array_header_t * svn_prop_array_dup(const apr_array_header_t *array, apr_pool_t *pool) { int i; apr_array_header_t *new_array = apr_array_copy(pool, array); for (i = 0; i < new_array->nelts; ++i) { svn_prop_t *elt = &APR_ARRAY_IDX(new_array, i, svn_prop_t); svn_prop__members_dup(elt, pool); } return new_array; } apr_array_header_t * svn_prop_hash_to_array(const apr_hash_t *hash, apr_pool_t *pool) { apr_hash_index_t *hi; apr_array_header_t *array = apr_array_make(pool, apr_hash_count((apr_hash_t *)hash), sizeof(svn_prop_t)); for (hi = apr_hash_first(pool, (apr_hash_t *)hash); hi; hi = apr_hash_next(hi)) { const void *key; void *val; svn_prop_t prop; apr_hash_this(hi, &key, NULL, &val); prop.name = key; prop.value = val; APR_ARRAY_PUSH(array, svn_prop_t) = prop; } return array; } apr_hash_t * svn_prop_hash_dup(const apr_hash_t *hash, apr_pool_t *pool) { apr_hash_index_t *hi; apr_hash_t *new_hash = apr_hash_make(pool); for (hi = apr_hash_first(pool, (apr_hash_t *)hash); hi; hi = apr_hash_next(hi)) { const void *key; apr_ssize_t klen; void *prop; apr_hash_this(hi, &key, &klen, &prop); apr_hash_set(new_hash, apr_pstrmemdup(pool, key, klen), klen, svn_string_dup(prop, pool)); } return new_hash; } apr_hash_t * svn_prop_array_to_hash(const apr_array_header_t *properties, apr_pool_t *pool) { int i; apr_hash_t *prop_hash = apr_hash_make(pool); for (i = 0; i < properties->nelts; i++) { const svn_prop_t *prop = &APR_ARRAY_IDX(properties, i, svn_prop_t); svn_hash_sets(prop_hash, prop->name, prop->value); } return prop_hash; } svn_boolean_t svn_prop_is_boolean(const char *prop_name) { /* If we end up with more than 3 of these, we should probably put them in a table and use bsearch. With only three, it doesn't make any speed difference. */ if (strcmp(prop_name, SVN_PROP_EXECUTABLE) == 0 || strcmp(prop_name, SVN_PROP_NEEDS_LOCK) == 0 || strcmp(prop_name, SVN_PROP_SPECIAL) == 0) return TRUE; return FALSE; } svn_boolean_t svn_prop_needs_translation(const char *propname) { /* ### Someday, we may want to be picky and choosy about which properties require UTF8 and EOL conversion. For now, all "svn:" props need it. */ return svn_prop_is_svn_prop(propname); } svn_boolean_t svn_prop_name_is_valid(const char *prop_name) { const char *p = prop_name; /* The characters we allow use identical representations in UTF8 and ASCII, so we can just test for the appropriate ASCII codes. But we can't use standard C character notation ('A', 'B', etc) because there's no guarantee that this C environment is using ASCII. */ if (!(svn_ctype_isalpha(*p) || *p == SVN_CTYPE_ASCII_COLON || *p == SVN_CTYPE_ASCII_UNDERSCORE)) return FALSE; p++; for (; *p; p++) { if (!(svn_ctype_isalnum(*p) || *p == SVN_CTYPE_ASCII_MINUS || *p == SVN_CTYPE_ASCII_DOT || *p == SVN_CTYPE_ASCII_COLON || *p == SVN_CTYPE_ASCII_UNDERSCORE)) return FALSE; } return TRUE; } const char * svn_prop_get_value(const apr_hash_t *props, const char *prop_name) { svn_string_t *str; if (!props) return NULL; str = svn_hash_gets((apr_hash_t *)props, prop_name); if (str) return str->data; return NULL; }