003 File Manager
Current Path:
/usr/src/contrib/subversion/subversion/libsvn_fs_base/bdb
usr
/
src
/
contrib
/
subversion
/
subversion
/
libsvn_fs_base
/
bdb
/
📁
..
📄
bdb-err.c
(2.9 KB)
📄
bdb-err.h
(4.24 KB)
📄
bdb_compat.c
(1.26 KB)
📄
bdb_compat.h
(4.57 KB)
📄
changes-table.c
(16.44 KB)
📄
changes-table.h
(3.68 KB)
📄
checksum-reps-table.c
(8.05 KB)
📄
checksum-reps-table.h
(3.77 KB)
📄
copies-table.c
(6.63 KB)
📄
copies-table.h
(3.75 KB)
📄
dbt.c
(3.83 KB)
📄
dbt.h
(4.14 KB)
📄
env.c
(22.57 KB)
📄
env.h
(5.34 KB)
📄
lock-tokens-table.c
(5.05 KB)
📄
lock-tokens-table.h
(3.33 KB)
📄
locks-table.c
(10.03 KB)
📄
locks-table.h
(4 KB)
📄
miscellaneous-table.c
(4.44 KB)
📄
miscellaneous-table.h
(2.5 KB)
📄
node-origins-table.c
(5.46 KB)
📄
node-origins-table.h
(3.19 KB)
📄
nodes-table.c
(8.27 KB)
📄
nodes-table.h
(4.93 KB)
📄
reps-table.c
(6.41 KB)
📄
reps-table.h
(3.45 KB)
📄
rev-table.c
(7.39 KB)
📄
rev-table.h
(3.03 KB)
📄
strings-table.c
(16.36 KB)
📄
strings-table.h
(5.29 KB)
📄
txn-table.c
(10.49 KB)
📄
txn-table.h
(3.86 KB)
📄
uuids-table.c
(4.33 KB)
📄
uuids-table.h
(2.35 KB)
Editing: locks-table.c
/* locks-table.c : operations on the `locks' table * * ==================================================================== * 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 <string.h> #include <assert.h> #include "bdb_compat.h" #include "svn_pools.h" #include "svn_path.h" #include "private/svn_skel.h" #include "dbt.h" #include "../err.h" #include "../fs.h" #include "../util/fs_skels.h" #include "../trail.h" #include "../../libsvn_fs/fs-loader.h" #include "bdb-err.h" #include "locks-table.h" #include "lock-tokens-table.h" #include "private/svn_fs_util.h" #include "private/svn_fspath.h" int svn_fs_bdb__open_locks_table(DB **locks_p, DB_ENV *env, svn_boolean_t create) { const u_int32_t open_flags = (create ? (DB_CREATE | DB_EXCL) : 0); DB *locks; int error; BDB_ERR(svn_fs_bdb__check_version()); BDB_ERR(db_create(&locks, env, 0)); error = (locks->open)(SVN_BDB_OPEN_PARAMS(locks, NULL), "locks", 0, DB_BTREE, open_flags, 0666); /* Create the table if it doesn't yet exist. This is a form of automagical repository upgrading. */ if (error == ENOENT && (! create)) { BDB_ERR(locks->close(locks, 0)); return svn_fs_bdb__open_locks_table(locks_p, env, TRUE); } BDB_ERR(error); *locks_p = locks; return 0; } svn_error_t * svn_fs_bdb__lock_add(svn_fs_t *fs, const char *lock_token, svn_lock_t *lock, trail_t *trail, apr_pool_t *pool) { base_fs_data_t *bfd = fs->fsap_data; svn_skel_t *lock_skel; DBT key, value; /* Convert native type to skel. */ SVN_ERR(svn_fs_base__unparse_lock_skel(&lock_skel, lock, pool)); svn_fs_base__str_to_dbt(&key, lock_token); svn_fs_base__skel_to_dbt(&value, lock_skel, pool); svn_fs_base__trail_debug(trail, "lock", "add"); return BDB_WRAP(fs, N_("storing lock record"), bfd->locks->put(bfd->locks, trail->db_txn, &key, &value, 0)); } svn_error_t * svn_fs_bdb__lock_delete(svn_fs_t *fs, const char *lock_token, trail_t *trail, apr_pool_t *pool) { base_fs_data_t *bfd = fs->fsap_data; DBT key; int db_err; svn_fs_base__str_to_dbt(&key, lock_token); svn_fs_base__trail_debug(trail, "locks", "del"); db_err = bfd->locks->del(bfd->locks, trail->db_txn, &key, 0); if (db_err == DB_NOTFOUND) return svn_fs_base__err_bad_lock_token(fs, lock_token); return BDB_WRAP(fs, N_("deleting lock from 'locks' table"), db_err); } svn_error_t * svn_fs_bdb__lock_get(svn_lock_t **lock_p, svn_fs_t *fs, const char *lock_token, trail_t *trail, apr_pool_t *pool) { base_fs_data_t *bfd = fs->fsap_data; DBT key, value; int db_err; svn_skel_t *skel; svn_lock_t *lock; svn_fs_base__trail_debug(trail, "lock", "get"); db_err = bfd->locks->get(bfd->locks, trail->db_txn, svn_fs_base__str_to_dbt(&key, lock_token), svn_fs_base__result_dbt(&value), 0); svn_fs_base__track_dbt(&value, pool); if (db_err == DB_NOTFOUND) return svn_fs_base__err_bad_lock_token(fs, lock_token); SVN_ERR(BDB_WRAP(fs, N_("reading lock"), db_err)); /* Parse TRANSACTION skel */ skel = svn_skel__parse(value.data, value.size, pool); if (! skel) return svn_fs_base__err_corrupt_lock(fs, lock_token); /* Convert skel to native type. */ SVN_ERR(svn_fs_base__parse_lock_skel(&lock, skel, pool)); /* Possibly auto-expire the lock. */ if (lock->expiration_date && (apr_time_now() > lock->expiration_date)) { SVN_ERR(svn_fs_bdb__lock_delete(fs, lock_token, trail, pool)); return SVN_FS__ERR_LOCK_EXPIRED(fs, lock_token); } *lock_p = lock; return SVN_NO_ERROR; } static svn_error_t * get_lock(svn_lock_t **lock_p, svn_fs_t *fs, const char *path, const char *lock_token, trail_t *trail, apr_pool_t *pool) { svn_error_t *err = SVN_NO_ERROR; *lock_p = NULL; /* Make sure the token points to an existing, non-expired lock, by doing a lookup in the `locks' table. Use 'pool'. */ err = svn_fs_bdb__lock_get(lock_p, fs, lock_token, trail, pool); if (err && ((err->apr_err == SVN_ERR_FS_LOCK_EXPIRED) || (err->apr_err == SVN_ERR_FS_BAD_LOCK_TOKEN))) { svn_error_clear(err); /* If `locks' doesn't have the lock, then we should lose it from `lock-tokens' table as well, then skip to the next matching path-key. */ err = svn_fs_bdb__lock_token_delete(fs, path, trail, pool); } return svn_error_trace(err); } svn_error_t * svn_fs_bdb__locks_get(svn_fs_t *fs, const char *path, svn_depth_t depth, svn_fs_get_locks_callback_t get_locks_func, void *get_locks_baton, trail_t *trail, apr_pool_t *pool) { base_fs_data_t *bfd = fs->fsap_data; DBC *cursor; DBT key, value; int db_err, db_c_err; apr_pool_t *subpool = svn_pool_create(pool); const char *lock_token; svn_lock_t *lock; svn_error_t *err; const char *lookup_path = path; apr_size_t lookup_len; /* First, try to lookup PATH itself. */ err = svn_fs_bdb__lock_token_get(&lock_token, fs, path, trail, pool); if (err && ((err->apr_err == SVN_ERR_FS_LOCK_EXPIRED) || (err->apr_err == SVN_ERR_FS_BAD_LOCK_TOKEN) || (err->apr_err == SVN_ERR_FS_NO_SUCH_LOCK))) { svn_error_clear(err); } else if (err) { return svn_error_trace(err); } else { SVN_ERR(get_lock(&lock, fs, path, lock_token, trail, pool)); if (lock && get_locks_func) { SVN_ERR(get_locks_func(get_locks_baton, lock, pool)); /* Found a lock so PATH is a file and we can ignore depth */ return SVN_NO_ERROR; } } /* If we're only looking at PATH itself (depth = empty), stop here. */ if (depth == svn_depth_empty) return SVN_NO_ERROR; /* Now go hunt for possible children of PATH. */ svn_fs_base__trail_debug(trail, "lock-tokens", "cursor"); db_err = bfd->lock_tokens->cursor(bfd->lock_tokens, trail->db_txn, &cursor, 0); SVN_ERR(BDB_WRAP(fs, N_("creating cursor for reading lock tokens"), db_err)); /* Since the key is going to be returned as well as the value make sure BDB malloc's the returned key. */ svn_fs_base__str_to_dbt(&key, lookup_path); key.flags |= DB_DBT_MALLOC; /* Get the first matching key that is either equal or greater than the one passed in, by passing in the DB_RANGE_SET flag. */ db_err = svn_bdb_dbc_get(cursor, &key, svn_fs_base__result_dbt(&value), DB_SET_RANGE); if (!svn_fspath__is_root(path, strlen(path))) lookup_path = apr_pstrcat(pool, path, "/", SVN_VA_NULL); lookup_len = strlen(lookup_path); /* As long as the prefix of the returned KEY matches LOOKUP_PATH we know it is either LOOKUP_PATH or a decendant thereof. */ while ((! db_err) && lookup_len < key.size && strncmp(lookup_path, key.data, lookup_len) == 0) { const char *child_path; svn_pool_clear(subpool); svn_fs_base__track_dbt(&key, subpool); svn_fs_base__track_dbt(&value, subpool); /* Create a usable path and token in temporary memory. */ child_path = apr_pstrmemdup(subpool, key.data, key.size); lock_token = apr_pstrmemdup(subpool, value.data, value.size); if ((depth == svn_depth_files) || (depth == svn_depth_immediates)) { /* On the assumption that we only store locks for files, depth=files and depth=immediates should boil down to the same set of results. So just see if CHILD_PATH is an immediate child of PATH. If not, we don't care about this item. */ const char *rel_path = svn_fspath__skip_ancestor(path, child_path); if (!rel_path || (svn_path_component_count(rel_path) != 1)) goto loop_it; } /* Get the lock for CHILD_PATH. */ err = get_lock(&lock, fs, child_path, lock_token, trail, subpool); if (err) { svn_bdb_dbc_close(cursor); return svn_error_trace(err); } /* Lock is verified, hand it off to our callback. */ if (lock && get_locks_func) { err = get_locks_func(get_locks_baton, lock, subpool); if (err) { svn_bdb_dbc_close(cursor); return svn_error_trace(err); } } loop_it: svn_fs_base__result_dbt(&key); svn_fs_base__result_dbt(&value); db_err = svn_bdb_dbc_get(cursor, &key, &value, DB_NEXT); } svn_pool_destroy(subpool); db_c_err = svn_bdb_dbc_close(cursor); if (db_err && (db_err != DB_NOTFOUND)) SVN_ERR(BDB_WRAP(fs, N_("fetching lock tokens"), db_err)); if (db_c_err) SVN_ERR(BDB_WRAP(fs, N_("fetching lock tokens (closing cursor)"), db_c_err)); return SVN_NO_ERROR; }
Upload File
Create Folder