svn_error_t * svn_fs_base__get_lock_helper(svn_lock_t **lock_p, const char *path, trail_t *trail, apr_pool_t *pool) { const char *lock_token; svn_error_t *err; err = svn_fs_bdb__lock_token_get(&lock_token, trail->fs, path, trail, pool); /* We've deliberately decided that this function doesn't tell the caller *why* the lock is unavailable. */ if (err && ((err->apr_err == SVN_ERR_FS_NO_SUCH_LOCK) || (err->apr_err == SVN_ERR_FS_LOCK_EXPIRED) || (err->apr_err == SVN_ERR_FS_BAD_LOCK_TOKEN))) { svn_error_clear(err); *lock_p = NULL; return SVN_NO_ERROR; } else SVN_ERR(err); /* Same situation here. */ err = svn_fs_bdb__lock_get(lock_p, trail->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); *lock_p = NULL; return SVN_NO_ERROR; } else SVN_ERR(err); return err; }
static svn_error_t * txn_body_unlock(void *baton, trail_t *trail) { struct unlock_args *args = baton; const char *lock_token; svn_lock_t *lock; /* This could return SVN_ERR_FS_BAD_LOCK_TOKEN or SVN_ERR_FS_LOCK_EXPIRED. */ SVN_ERR(svn_fs_bdb__lock_token_get(&lock_token, trail->fs, args->path, trail, trail->pool)); /* If not breaking the lock, we need to do some more checking. */ if (!args->break_lock) { /* Sanity check: The lock token must exist, and must match. */ if (args->token == NULL) return svn_fs_base__err_no_lock_token(trail->fs, args->path); else if (strcmp(lock_token, args->token) != 0) return SVN_FS__ERR_NO_SUCH_LOCK(trail->fs, args->path); SVN_ERR(svn_fs_bdb__lock_get(&lock, trail->fs, lock_token, trail, trail->pool)); /* There better be a username attached to the fs. */ if (!trail->fs->access_ctx || !trail->fs->access_ctx->username) return SVN_FS__ERR_NO_USER(trail->fs); /* And that username better be the same as the lock's owner. */ if (strcmp(trail->fs->access_ctx->username, lock->owner) != 0) return SVN_FS__ERR_LOCK_OWNER_MISMATCH (trail->fs, trail->fs->access_ctx->username, lock->owner); } /* Remove a row from each of the locking tables. */ return delete_lock_and_token(lock_token, args->path, trail); }
svn_error_t * svn_fs_bdb__locks_get(svn_fs_t *fs, const char *path, 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; /* 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 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)); } /* Now go hunt for possible children of PATH. */ if (strcmp(path, "/") != 0) lookup_path = apr_pstrcat(pool, path, "/", NULL); 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, "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); /* 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) && strncmp(lookup_path, key.data, strlen(lookup_path)) == 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); /* 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 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 err; } } 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, "fetching lock tokens", db_err)); if (db_c_err) SVN_ERR(BDB_WRAP(fs, "fetching lock tokens (closing cursor)", db_c_err)); return SVN_NO_ERROR; }
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; /* 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)); } /* 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, "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, "/", (char *)NULL); /* 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) && strncmp(lookup_path, key.data, strlen(lookup_path)) == 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__is_child(path, child_path, subpool); 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, "fetching lock tokens", db_err)); if (db_c_err) SVN_ERR(BDB_WRAP(fs, "fetching lock tokens (closing cursor)", db_c_err)); return SVN_NO_ERROR; }