lock.c revision 6f984345bbfa9342dde1f2b7b8c35b7987d078af
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder/* ====================================================================
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * The Apache Software License, Version 1.1
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder *
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * Copyright (c) 2000 The Apache Software Foundation. All rights
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * reserved.
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder *
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * Redistribution and use in source and binary forms, with or without
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * modification, are permitted provided that the following conditions
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * are met:
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder *
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * 1. Redistributions of source code must retain the above copyright
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * notice, this list of conditions and the following disclaimer.
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder *
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * 2. Redistributions in binary form must reproduce the above copyright
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * notice, this list of conditions and the following disclaimer in
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * the documentation and/or other materials provided with the
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * distribution.
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder *
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * 3. The end-user documentation included with the redistribution,
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * if any, must include the following acknowledgment:
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * "This product includes software developed by the
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * Apache Software Foundation (http://www.apache.org/)."
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * Alternately, this acknowledgment may appear in the software itself,
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * if and wherever such third-party acknowledgments normally appear.
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder *
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * 4. The names "Apache" and "Apache Software Foundation" must
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * not be used to endorse or promote products derived from this
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * software without prior written permission. For written
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * permission, please contact apache@apache.org.
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder *
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder * 5. Products derived from this software may not be called "Apache",
96de7ec4008f75574077816c4c71a22e6afe1e01Christian Maeder * nor may "Apache" appear in their name, without prior written
96de7ec4008f75574077816c4c71a22e6afe1e01Christian Maeder * permission of the Apache Software Foundation.
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder *
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
162a689da386fc8ddbbe47bcae83eaca4fc8dbc0Christian Maeder * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder * SUCH DAMAGE.
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * ====================================================================
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder *
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * This software consists of voluntary contributions made by many
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * individuals on behalf of the Apache Software Foundation. For more
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * information on the Apache Software Foundation, please see
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * <http://www.apache.org/>.
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder */
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maeder/*
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maeder** DAV filesystem lock implementation
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder*/
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder#include "apr.h"
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder#include "apr_strings.h"
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder#include "apr_file_io.h"
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder#include "apr_uuid.h"
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder#include "httpd.h"
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder#include "http_log.h"
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder#include "mod_dav.h"
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder#include "repos.h"
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder/* ---------------------------------------------------------------
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder**
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** Lock database primitives
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder**
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder*/
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder/*
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** LOCK DATABASES
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder**
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** Lockdiscovery information is stored in the single lock database specified
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** by the DAVLockDB directive. Information about this db is stored in the
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** global server configuration.
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder**
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** KEY
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder**
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** The database is keyed by a key_type unsigned char (DAV_TYPE_INODE or
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** DAV_TYPE_FNAME) followed by inode and device number if possible,
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** otherwise full path (in the case of Win32 or lock-null resources).
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder**
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** VALUE
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder**
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** The value consists of a list of elements.
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** DIRECT LOCK: [char (DAV_LOCK_DIRECT),
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** char (dav_lock_scope),
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** char (dav_lock_type),
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** int depth,
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder** time_t expires,
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** apr_uuid_t locktoken,
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** char[] owner,
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** char[] auth_user]
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder**
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** INDIRECT LOCK: [char (DAV_LOCK_INDIRECT),
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** apr_uuid_t locktoken,
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** time_t expires,
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** int key_size,
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** char[] key]
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** The key is to the collection lock that resulted in this indirect lock
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder*/
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder#define DAV_TRUE 1
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder#define DAV_FALSE 0
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder#define DAV_CREATE_LIST 23
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder#define DAV_APPEND_LIST 24
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder/* Stored lock_discovery prefix */
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder#define DAV_LOCK_DIRECT 1
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder#define DAV_LOCK_INDIRECT 2
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder#define DAV_TYPE_INODE 10
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder#define DAV_TYPE_FNAME 11
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder/* ack. forward declare. */
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maederstatic dav_error * dav_fs_remove_locknull_member(apr_pool_t *p,
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder const char *filename,
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder dav_buffer *pbuf);
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder/*
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** Use the opaquelock scheme for locktokens
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder*/
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maederstruct dav_locktoken {
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder apr_uuid_t uuid;
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder};
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder#define dav_compare_locktoken(plt1, plt2) \
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder memcmp(&(plt1)->uuid, &(plt2)->uuid, sizeof((plt1)->uuid))
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder/* #################################################################
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** ### keep these structures (internal) or move fully to dav_lock?
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder*/
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder/*
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** We need to reliably size the fixed-length portion of
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** dav_lock_discovery; best to separate it into another
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** struct for a convenient sizeof, unless we pack lock_discovery.
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder*/
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maedertypedef struct dav_lock_discovery_fixed
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder{
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder char scope;
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder char type;
31c6978fd9066c9d2c3c98c950f7abbe89112522Christian Maeder int depth;
31c6978fd9066c9d2c3c98c950f7abbe89112522Christian Maeder time_t timeout;
31c6978fd9066c9d2c3c98c950f7abbe89112522Christian Maeder} dav_lock_discovery_fixed;
31c6978fd9066c9d2c3c98c950f7abbe89112522Christian Maeder
31c6978fd9066c9d2c3c98c950f7abbe89112522Christian Maedertypedef struct dav_lock_discovery
31c6978fd9066c9d2c3c98c950f7abbe89112522Christian Maeder{
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder struct dav_lock_discovery_fixed f;
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder dav_locktoken *locktoken;
162a689da386fc8ddbbe47bcae83eaca4fc8dbc0Christian Maeder const char *owner; /* owner field from activelock */
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder const char *auth_user; /* authenticated user who created the lock */
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder struct dav_lock_discovery *next;
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder} dav_lock_discovery;
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder/* Indirect locks represent locks inherited from containing collections.
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * They reference the lock token for the collection the lock is
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * inherited from. A lock provider may also define a key to the
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * inherited lock, for fast datbase lookup. The key is opaque outside
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder * the lock provider.
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder */
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maedertypedef struct dav_lock_indirect
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder{
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder dav_locktoken *locktoken;
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder dav_datum key;
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder struct dav_lock_indirect *next;
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder time_t timeout;
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder} dav_lock_indirect;
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
31c6978fd9066c9d2c3c98c950f7abbe89112522Christian Maeder/* ################################################################# */
31c6978fd9066c9d2c3c98c950f7abbe89112522Christian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder/*
31c6978fd9066c9d2c3c98c950f7abbe89112522Christian Maeder** Stored direct lock info - full lock_discovery length:
31c6978fd9066c9d2c3c98c950f7abbe89112522Christian Maeder** prefix + Fixed length + lock token + 2 strings + 2 nulls (one for each string)
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder*/
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder#define dav_size_direct(a) (1 + sizeof(dav_lock_discovery_fixed) \
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder + sizeof(apr_uuid_t) \
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder + ((a)->owner ? strlen((a)->owner) : 0) \
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder + ((a)->auth_user ? strlen((a)->auth_user) : 0) \
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder + 2)
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder/* Stored indirect lock info - lock token and dav_datum */
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder#define dav_size_indirect(a) (1 + sizeof(apr_uuid_t) \
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder + sizeof(time_t) \
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder + sizeof(int) + (a)->key.dsize)
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder/*
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** The lockdb structure.
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder**
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** The <db> field may be NULL, meaning one of two things:
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** 1) That we have not actually opened the underlying database (yet). The
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** <opened> field should be false.
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** 2) We opened it readonly and it wasn't present.
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder**
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** The delayed opening (determined by <opened>) makes creating a lockdb
31c6978fd9066c9d2c3c98c950f7abbe89112522Christian Maeder** quick, while deferring the underlying I/O until it is actually required.
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder**
31c6978fd9066c9d2c3c98c950f7abbe89112522Christian Maeder** We export the notion of a lockdb, but hide the details of it. Most
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** implementations will use a database of some kind, but it is certainly
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** possible that alternatives could be used.
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder*/
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maederstruct dav_lockdb_private
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder{
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder request_rec *r; /* for accessing the uuid state */
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder apr_pool_t *pool; /* a pool to use */
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder const char *lockdb_path; /* where is the lock database? */
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder int opened; /* we opened the database */
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder dav_db *db; /* if non-NULL, the lock database */
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder};
31c6978fd9066c9d2c3c98c950f7abbe89112522Christian Maedertypedef struct
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder{
31c6978fd9066c9d2c3c98c950f7abbe89112522Christian Maeder dav_lockdb pub;
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder dav_lockdb_private priv;
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder} dav_lockdb_combined;
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder/*
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** The private part of the lock structure.
31c6978fd9066c9d2c3c98c950f7abbe89112522Christian Maeder*/
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maederstruct dav_lock_private
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder{
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder dav_datum key; /* key into the lock database */
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder};
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maedertypedef struct
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maeder{
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maeder dav_lock pub;
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maeder dav_lock_private priv;
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder dav_locktoken token;
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder} dav_lock_combined;
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder/*
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder** This must be forward-declared so the open_lockdb function can use it.
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder*/
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maederextern const dav_hooks_locks dav_hooks_locks_fs;
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder/* internal function for creating locks */
162a689da386fc8ddbbe47bcae83eaca4fc8dbc0Christian Maederstatic dav_lock *dav_fs_alloc_lock(dav_lockdb *lockdb, dav_datum key,
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder const dav_locktoken *locktoken)
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder{
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder dav_lock_combined *comb;
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder comb = apr_pcalloc(lockdb->info->pool, sizeof(*comb));
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder comb->pub.rectype = DAV_LOCKREC_DIRECT;
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder comb->pub.info = &comb->priv;
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder comb->priv.key = key;
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maeder if (locktoken == NULL) {
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maeder comb->pub.locktoken = &comb->token;
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maeder apr_get_uuid(&comb->token.uuid);
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maeder }
96de7ec4008f75574077816c4c71a22e6afe1e01Christian Maeder else {
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maeder comb->pub.locktoken = locktoken;
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maeder }
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maeder
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maeder return &comb->pub;
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maeder}
96de7ec4008f75574077816c4c71a22e6afe1e01Christian Maeder
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maeder/*
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maeder** dav_fs_parse_locktoken
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maeder**
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maeder** Parse an opaquelocktoken URI into a locktoken.
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maeder*/
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maederstatic dav_error * dav_fs_parse_locktoken(
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder apr_pool_t *p,
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder const char *char_token,
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder dav_locktoken **locktoken_p)
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder{
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder dav_locktoken *locktoken;
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maeder
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maeder if (ap_strstr_c(char_token, "opaquelocktoken:") != char_token) {
ce59e0cc5c7221245ed323290bfccbda4ee32dd9Christian Maeder return dav_new_error(p,
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder HTTP_BAD_REQUEST, DAV_ERR_LOCK_UNK_STATE_TOKEN,
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder "The lock token uses an unknown State-token "
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder "format and could not be parsed.");
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder }
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder char_token += 16;
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder locktoken = apr_pcalloc(p, sizeof(*locktoken));
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder if (apr_parse_uuid(&locktoken->uuid, char_token)) {
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder return dav_new_error(p, HTTP_BAD_REQUEST, DAV_ERR_LOCK_PARSE_TOKEN,
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder "The opaquelocktoken has an incorrect format "
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder "and could not be parsed.");
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder }
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder *locktoken_p = locktoken;
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder return NULL;
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder}
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder/*
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder** dav_fs_format_locktoken
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder**
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder** Generate the URI for a locktoken
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder*/
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maederstatic const char *dav_fs_format_locktoken(
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder apr_pool_t *p,
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder const dav_locktoken *locktoken)
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder{
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder char buf[APR_UUID_FORMATTED_LENGTH + 1];
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder apr_format_uuid(buf, &locktoken->uuid);
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder return apr_pstrcat(p, "opaquelocktoken:", buf, NULL);
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder}
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder/*
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder** dav_fs_compare_locktoken
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder**
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder** Determine whether two locktokens are the same
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder*/
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maederstatic int dav_fs_compare_locktoken(
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder const dav_locktoken *lt1,
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder const dav_locktoken *lt2)
af1cb109bce240bcafe3823df022d6088cbfc438Christian Maeder{
bd8ff5b5f66be563e5be9d3a0c069e32d06f331cChristian Maeder return dav_compare_locktoken(lt1, lt2);
96de7ec4008f75574077816c4c71a22e6afe1e01Christian Maeder}
/*
** dav_fs_really_open_lockdb:
**
** If the database hasn't been opened yet, then open the thing.
*/
static dav_error * dav_fs_really_open_lockdb(dav_lockdb *lockdb)
{
dav_error *err;
if (lockdb->info->opened)
return NULL;
err = dav_dbm_open_direct(lockdb->info->pool,
lockdb->info->lockdb_path,
lockdb->ro,
&lockdb->info->db);
if (err != NULL) {
return dav_push_error(lockdb->info->pool,
HTTP_INTERNAL_SERVER_ERROR,
DAV_ERR_LOCK_OPENDB,
"Could not open the lock database.",
err);
}
/* all right. it is opened now. */
lockdb->info->opened = 1;
return NULL;
}
/*
** dav_fs_open_lockdb:
**
** "open" the lock database, as specified in the global server configuration.
** If force is TRUE, then the database is opened now, rather than lazily.
**
** Note that only one can be open read/write.
*/
static dav_error * dav_fs_open_lockdb(request_rec *r, int ro, int force,
dav_lockdb **lockdb)
{
dav_lockdb_combined *comb;
comb = apr_pcalloc(r->pool, sizeof(*comb));
comb->pub.hooks = &dav_hooks_locks_fs;
comb->pub.ro = ro;
comb->pub.info = &comb->priv;
comb->priv.r = r;
comb->priv.pool = r->pool;
comb->priv.lockdb_path = dav_get_lockdb_path(r);
if (comb->priv.lockdb_path == NULL) {
return dav_new_error(r->pool, HTTP_INTERNAL_SERVER_ERROR,
DAV_ERR_LOCK_NO_DB,
"A lock database was not specified with the "
"DAVLockDB directive. One must be specified "
"to use the locking functionality.");
}
/* done initializing. return it. */
*lockdb = &comb->pub;
if (force) {
/* ### add a higher-level comment? */
return dav_fs_really_open_lockdb(*lockdb);
}
return NULL;
}
/*
** dav_fs_close_lockdb:
**
** Close it. Duh.
*/
static void dav_fs_close_lockdb(dav_lockdb *lockdb)
{
if (lockdb->info->db != NULL)
(*dav_hooks_db_dbm.close)(lockdb->info->db);
}
/*
** dav_fs_build_fname_key
**
** Given a pathname, build a DAV_TYPE_FNAME lock database key.
*/
static dav_datum dav_fs_build_fname_key(apr_pool_t *p, const char *pathname)
{
dav_datum key;
/* ### does this allocation have a proper lifetime? need to check */
/* ### can we use a buffer for this? */
/* size is TYPE + pathname + null */
key.dsize = strlen(pathname) + 2;
key.dptr = apr_palloc(p, key.dsize);
*key.dptr = DAV_TYPE_FNAME;
memcpy(key.dptr + 1, pathname, key.dsize - 1);
if (key.dptr[key.dsize - 2] == '/')
key.dptr[--key.dsize - 1] = '\0';
return key;
}
/*
** dav_fs_build_key: Given a resource, return a dav_datum key
** to look up lock information for this file.
**
** (Win32 or file is lock-null):
** dav_datum->dvalue = full path
**
** (non-Win32 and file exists ):
** dav_datum->dvalue = inode, dev_major, dev_minor
*/
static dav_datum dav_fs_build_key(apr_pool_t *p, const dav_resource *resource)
{
const char *file = dav_fs_pathname(resource);
#ifndef WIN32
dav_datum key;
apr_finfo_t finfo;
/* ### use lstat() ?? */
if (apr_stat(&finfo, file, APR_FINFO_NORM, p) == APR_SUCCESS) {
/* ### can we use a buffer for this? */
key.dsize = 1 + sizeof(finfo.inode) + sizeof(finfo.device);
key.dptr = apr_palloc(p, key.dsize);
*key.dptr = DAV_TYPE_INODE;
memcpy(key.dptr + 1, &finfo.inode, sizeof(finfo.inode));
memcpy(key.dptr + 1 + sizeof(finfo.inode), &finfo.device,
sizeof(finfo.device));
return key;
}
#endif
return dav_fs_build_fname_key(p, file);
}
/*
** dav_fs_lock_expired: return 1 (true) if the given timeout is in the past
** or present (the lock has expired), or 0 (false) if in the future
** (the lock has not yet expired).
*/
static int dav_fs_lock_expired(time_t expires)
{
return expires != DAV_TIMEOUT_INFINITE && time(NULL) >= expires;
}
/*
** dav_fs_save_lock_record: Saves the lock information specified in the
** direct and indirect lock lists about path into the lock database.
** If direct and indirect == NULL, the key is removed.
*/
static dav_error * dav_fs_save_lock_record(dav_lockdb *lockdb, dav_datum key,
dav_lock_discovery *direct,
dav_lock_indirect *indirect)
{
dav_error *err;
dav_datum val = { 0 };
char *ptr;
dav_lock_discovery *dp = direct;
dav_lock_indirect *ip = indirect;
#if DAV_DEBUG
if (lockdb->ro) {
return dav_new_error(lockdb->info->pool,
HTTP_INTERNAL_SERVER_ERROR, 0,
"INTERNAL DESIGN ERROR: the lockdb was opened "
"readonly, but an attempt to save locks was "
"performed.");
}
#endif
if ((err = dav_fs_really_open_lockdb(lockdb)) != NULL) {
/* ### add a higher-level error? */
return err;
}
/* If nothing to save, delete key */
if (dp == NULL && ip == NULL) {
/* don't fail if the key is not present */
/* ### but what about other errors? */
(void) (*dav_hooks_db_dbm.remove)(lockdb->info->db, key);
return NULL;
}
while(dp) {
val.dsize += dav_size_direct(dp);
dp = dp->next;
}
while(ip) {
val.dsize += dav_size_indirect(ip);
ip = ip->next;
}
/* ### can this be apr_palloc() ? */
/* ### hmmm.... investigate the use of a buffer here */
ptr = val.dptr = apr_pcalloc(lockdb->info->pool, val.dsize);
dp = direct;
ip = indirect;
while(dp) {
*ptr++ = DAV_LOCK_DIRECT; /* Direct lock - lock_discovery struct follows */
memcpy(ptr, dp, sizeof(dp->f)); /* Fixed portion of struct */
ptr += sizeof(dp->f);
memcpy(ptr, dp->locktoken, sizeof(*dp->locktoken));
ptr += sizeof(*dp->locktoken);
if (dp->owner == NULL) {
*ptr++ = '\0';
}
else {
memcpy(ptr, dp->owner, strlen(dp->owner) + 1);
ptr += strlen(dp->owner) + 1;
}
if (dp->auth_user == NULL) {
*ptr++ = '\0';
}
else {
memcpy(ptr, dp->auth_user, strlen(dp->auth_user) + 1);
ptr += strlen(dp->auth_user) + 1;
}
dp = dp->next;
}
while(ip) {
*ptr++ = DAV_LOCK_INDIRECT; /* Indirect lock prefix */
memcpy(ptr, ip->locktoken, sizeof(*ip->locktoken)); /* Locktoken */
ptr += sizeof(*ip->locktoken);
memcpy(ptr, &ip->timeout, sizeof(ip->timeout)); /* Expire time */
ptr += sizeof(ip->timeout);
memcpy(ptr, &ip->key.dsize, sizeof(ip->key.dsize)); /* Size of key */
ptr += sizeof(ip->key.dsize);
memcpy(ptr, ip->key.dptr, ip->key.dsize); /* Key data */
ptr += ip->key.dsize;
ip = ip->next;
}
if ((err = (*dav_hooks_db_dbm.store)(lockdb->info->db,
key, val)) != NULL) {
/* ### more details? add an error_id? */
return dav_push_error(lockdb->info->pool,
HTTP_INTERNAL_SERVER_ERROR,
DAV_ERR_LOCK_SAVE_LOCK,
"Could not save lock information.",
err);
}
return NULL;
}
/*
** dav_load_lock_record: Reads lock information about key from lock db;
** creates linked lists of the direct and indirect locks.
**
** If add_method = DAV_APPEND_LIST, the result will be appended to the
** head of the direct and indirect lists supplied.
**
** Passive lock removal: If lock has timed out, it will not be returned.
** ### How much "logging" does RFC 2518 require?
*/
static dav_error * dav_fs_load_lock_record(dav_lockdb *lockdb, dav_datum key,
int add_method,
dav_lock_discovery **direct,
dav_lock_indirect **indirect)
{
apr_pool_t *p = lockdb->info->pool;
dav_error *err;
apr_size_t offset = 0;
int need_save = DAV_FALSE;
dav_datum val = { 0 };
dav_lock_discovery *dp;
dav_lock_indirect *ip;
dav_buffer buf = { 0 };
if (add_method != DAV_APPEND_LIST) {
*direct = NULL;
*indirect = NULL;
}
if ((err = dav_fs_really_open_lockdb(lockdb)) != NULL) {
/* ### add a higher-level error? */
return err;
}
/*
** If we opened readonly and the db wasn't there, then there are no
** locks for this resource. Just exit.
*/
if (lockdb->info->db == NULL)
return NULL;
if ((err = (*dav_hooks_db_dbm.fetch)(lockdb->info->db, key, &val)) != NULL)
return err;
if (!val.dsize)
return NULL;
while (offset < val.dsize) {
switch (*(val.dptr + offset++)) {
case DAV_LOCK_DIRECT:
/* Create and fill a dav_lock_discovery structure */
dp = apr_pcalloc(p, sizeof(*dp));
memcpy(dp, val.dptr + offset, sizeof(dp->f));
offset += sizeof(dp->f);
dp->locktoken = apr_palloc(p, sizeof(*dp->locktoken));
memcpy(dp->locktoken, val.dptr + offset, sizeof(*dp->locktoken));
offset += sizeof(*dp->locktoken);
if (*(val.dptr + offset) == '\0') {
++offset;
}
else {
dp->owner = apr_pstrdup(p, val.dptr + offset);
offset += strlen(dp->owner) + 1;
}
if (*(val.dptr + offset) == '\0') {
++offset;
}
else {
dp->auth_user = apr_pstrdup(p, val.dptr + offset);
offset += strlen(dp->auth_user) + 1;
}
if (!dav_fs_lock_expired(dp->f.timeout)) {
dp->next = *direct;
*direct = dp;
}
else {
need_save = DAV_TRUE;
/* Remove timed-out locknull fm .locknull list */
if (*key.dptr == DAV_TYPE_FNAME) {
const char *fname = key.dptr + 1;
apr_finfo_t finfo;
/* if we don't see the file, then it's a locknull */
if (apr_lstat(&finfo, fname, APR_FINFO_NORM, p) != APR_SUCCESS) {
if ((err = dav_fs_remove_locknull_member(p, fname, &buf)) != NULL) {
/* ### push a higher-level description? */
return err;
}
}
}
}
break;
case DAV_LOCK_INDIRECT:
/* Create and fill a dav_lock_indirect structure */
ip = apr_pcalloc(p, sizeof(*ip));
ip->locktoken = apr_palloc(p, sizeof(*ip->locktoken));
memcpy(ip->locktoken, val.dptr + offset, sizeof(*ip->locktoken));
offset += sizeof(*ip->locktoken);
memcpy(&ip->timeout, val.dptr + offset, sizeof(ip->timeout));
offset += sizeof(ip->timeout);
ip->key.dsize = *((int *) (val.dptr + offset)); /* length of datum */
offset += sizeof(ip->key.dsize);
ip->key.dptr = apr_palloc(p, ip->key.dsize);
memcpy(ip->key.dptr, val.dptr + offset, ip->key.dsize);
offset += ip->key.dsize;
if (!dav_fs_lock_expired(ip->timeout)) {
ip->next = *indirect;
*indirect = ip;
}
else {
need_save = DAV_TRUE;
/* A locknull resource will never be locked indirectly */
}
break;
default:
(*dav_hooks_db_dbm.freedatum)(lockdb->info->db, val);
/* ### should use a computed_desc and insert corrupt token data */
--offset;
return dav_new_error(p,
HTTP_INTERNAL_SERVER_ERROR,
DAV_ERR_LOCK_CORRUPT_DB,
apr_psprintf(p,
"The lock database was found to "
"be corrupt. offset %i, c=%02x",
offset, val.dptr[offset]));
}
}
(*dav_hooks_db_dbm.freedatum)(lockdb->info->db, val);
/* Clean up this record if we found expired locks */
/*
** ### shouldn't do this if we've been opened READONLY. elide the
** ### timed-out locks from the response, but don't save that info back
*/
if (need_save == DAV_TRUE) {
return dav_fs_save_lock_record(lockdb, key, *direct, *indirect);
}
return NULL;
}
/* resolve <indirect>, returning <*direct> */
static dav_error * dav_fs_resolve(dav_lockdb *lockdb,
dav_lock_indirect *indirect,
dav_lock_discovery **direct,
dav_lock_discovery **ref_dp,
dav_lock_indirect **ref_ip)
{
dav_error *err;
dav_lock_discovery *dir;
dav_lock_indirect *ind;
if ((err = dav_fs_load_lock_record(lockdb, indirect->key,
DAV_CREATE_LIST,
&dir, &ind)) != NULL) {
/* ### insert a higher-level description? */
return err;
}
if (ref_dp != NULL) {
*ref_dp = dir;
*ref_ip = ind;
}
for (; dir != NULL; dir = dir->next) {
if (!dav_compare_locktoken(indirect->locktoken, dir->locktoken)) {
*direct = dir;
return NULL;
}
}
/* No match found (but we should have found one!) */
/* ### use a different description and/or error ID? */
return dav_new_error(lockdb->info->pool,
HTTP_INTERNAL_SERVER_ERROR,
DAV_ERR_LOCK_CORRUPT_DB,
"The lock database was found to be corrupt. "
"An indirect lock's direct lock could not "
"be found.");
}
/* ---------------------------------------------------------------
**
** Property-related lock functions
**
*/
/*
** dav_fs_get_supportedlock: Returns a static string for all supportedlock
** properties. I think we save more returning a static string than
** constructing it every time, though it might look cleaner.
*/
static const char *dav_fs_get_supportedlock(const dav_resource *resource)
{
static const char supported[] = DEBUG_CR
"<D:lockentry>" DEBUG_CR
"<D:lockscope><D:exclusive/></D:lockscope>" DEBUG_CR
"<D:locktype><D:write/></D:locktype>" DEBUG_CR
"</D:lockentry>" DEBUG_CR
"<D:lockentry>" DEBUG_CR
"<D:lockscope><D:shared/></D:lockscope>" DEBUG_CR
"<D:locktype><D:write/></D:locktype>" DEBUG_CR
"</D:lockentry>" DEBUG_CR;
return supported;
}
/* ---------------------------------------------------------------
**
** General lock functions
**
*/
/* ---------------------------------------------------------------
**
** Functions dealing with lock-null resources
**
*/
/*
** dav_fs_load_locknull_list: Returns a dav_buffer dump of the locknull file
** for the given directory.
*/
static dav_error * dav_fs_load_locknull_list(apr_pool_t *p, const char *dirpath,
dav_buffer *pbuf)
{
apr_finfo_t finfo;
apr_file_t *file = NULL;
dav_error *err = NULL;
apr_ssize_t amt;
dav_buffer_init(p, pbuf, dirpath);
if (pbuf->buf[pbuf->cur_len - 1] == '/')
pbuf->buf[--pbuf->cur_len] = '\0';
dav_buffer_place(p, pbuf, "/" DAV_FS_STATE_DIR "/" DAV_FS_LOCK_NULL_FILE);
/* reset this in case we leave w/o reading into the buffer */
pbuf->cur_len = 0;
if (apr_open(&file, pbuf->buf, APR_READ | APR_BINARY, APR_OS_DEFAULT,
p) != APR_SUCCESS) {
return NULL;
}
if (apr_getfileinfo(&finfo, APR_FINFO_NORM, file) != APR_SUCCESS) {
err = dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0,
apr_psprintf(p,
"Opened but could not stat file %s",
pbuf->buf));
goto loaderror;
}
dav_set_bufsize(p, pbuf, finfo.size);
amt = finfo.size;
if (apr_read(file, pbuf->buf, &amt) != APR_SUCCESS
|| amt != finfo.size) {
err = dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0,
apr_psprintf(p,
"Failure reading locknull file "
"for %s", dirpath));
/* just in case the caller disregards the returned error */
pbuf->cur_len = 0;
goto loaderror;
}
loaderror:
apr_close(file);
return err;
}
/*
** dav_fs_save_locknull_list: Saves contents of pbuf into the
** locknull file for dirpath.
*/
static dav_error * dav_fs_save_locknull_list(apr_pool_t *p, const char *dirpath,
dav_buffer *pbuf)
{
const char *pathname;
apr_file_t *file = NULL;
dav_error *err = NULL;
apr_ssize_t amt;
if (pbuf->buf == NULL)
return NULL;
dav_fs_ensure_state_dir(p, dirpath);
pathname = apr_pstrcat(p,
dirpath,
dirpath[strlen(dirpath) - 1] == '/' ? "" : "/",
DAV_FS_STATE_DIR "/" DAV_FS_LOCK_NULL_FILE,
NULL);
if (pbuf->cur_len == 0) {
/* delete the file if cur_len == 0 */
if (apr_remove_file(pathname, p) != 0) {
return dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0,
apr_psprintf(p,
"Error removing %s", pathname));
}
return NULL;
}
if (apr_open(&file, pathname,
APR_WRITE | APR_CREATE | APR_TRUNCATE | APR_BINARY,
APR_OS_DEFAULT, p) != APR_SUCCESS) {
return dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0,
apr_psprintf(p,
"Error opening %s for writing",
pathname));
}
amt = pbuf->cur_len;
if (apr_write(file, pbuf->buf, &amt) != APR_SUCCESS
|| amt != pbuf->cur_len) {
err = dav_new_error(p, HTTP_INTERNAL_SERVER_ERROR, 0,
apr_psprintf(p,
"Error writing %i bytes to %s",
pbuf->cur_len, pathname));
}
apr_close(file);
return err;
}
/*
** dav_fs_remove_locknull_member: Removes filename from the locknull list
** for directory path.
*/
static dav_error * dav_fs_remove_locknull_member(apr_pool_t *p,
const char *filename,
dav_buffer *pbuf)
{
dav_error *err;
apr_size_t len;
apr_size_t scanlen;
char *scan;
const char *scanend;
char *dirpath = apr_pstrdup(p, filename);
char *fname = strrchr(dirpath, '/');
int dirty = 0;
if (fname != NULL)
*fname++ = '\0';
else
fname = dirpath;
len = strlen(fname) + 1;
if ((err = dav_fs_load_locknull_list(p, dirpath, pbuf)) != NULL) {
/* ### add a higher level description? */
return err;
}
for (scan = pbuf->buf, scanend = scan + pbuf->cur_len;
scan < scanend;
scan += scanlen) {
scanlen = strlen(scan) + 1;
if (len == scanlen && memcmp(fname, scan, scanlen) == 0) {
pbuf->cur_len -= scanlen;
memmove(scan, scan + scanlen, scanend - (scan + scanlen));
dirty = 1;
break;
}
}
if (dirty) {
if ((err = dav_fs_save_locknull_list(p, dirpath, pbuf)) != NULL) {
/* ### add a higher level description? */
return err;
}
}
return NULL;
}
/* Note: used by dav_fs_repos.c */
dav_error * dav_fs_get_locknull_members(
const dav_resource *resource,
dav_buffer *pbuf)
{
const char *dirpath;
dav_fs_dir_file_name(resource, &dirpath, NULL);
return dav_fs_load_locknull_list(dav_fs_pool(resource), dirpath, pbuf);
}
/* ### fold into append_lock? */
/* ### take an optional buf parameter? */
static dav_error * dav_fs_add_locknull_state(
dav_lockdb *lockdb,
const dav_resource *resource)
{
dav_buffer buf = { 0 };
apr_pool_t *p = lockdb->info->pool;
const char *dirpath;
const char *fname;
dav_error *err;
dav_fs_dir_file_name(resource, &dirpath, &fname);
if ((err = dav_fs_load_locknull_list(p, dirpath, &buf)) != NULL) {
return dav_push_error(p, HTTP_INTERNAL_SERVER_ERROR, 0,
"Could not load .locknull file.", err);
}
dav_buffer_append(p, &buf, fname);
buf.cur_len++; /* we want the null-term here */
if ((err = dav_fs_save_locknull_list(p, dirpath, &buf)) != NULL) {
return dav_push_error(p, HTTP_INTERNAL_SERVER_ERROR, 0,
"Could not save .locknull file.", err);
}
return NULL;
}
/*
** dav_fs_remove_locknull_state: Given a request, check to see if r->filename
** is/was a lock-null resource. If so, return it to an existant state.
**
** ### this function is broken... it doesn't check!
**
** In this implementation, this involves two things:
** (a) remove it from the list in the appropriate .DAV/locknull file
** (b) on *nix, convert the key from a filename to an inode.
*/
static dav_error * dav_fs_remove_locknull_state(
dav_lockdb *lockdb,
const dav_resource *resource)
{
dav_buffer buf = { 0 };
dav_error *err;
apr_pool_t *p = lockdb->info->pool;
const char *pathname = dav_fs_pathname(resource);
if ((err = dav_fs_remove_locknull_member(p, pathname, &buf)) != NULL) {
/* ### add a higher-level description? */
return err;
}
#ifndef WIN32
{
dav_lock_discovery *ld;
dav_lock_indirect *id;
dav_datum key;
/*
** Fetch the lock(s) that made the resource lock-null. Remove
** them under the filename key. Obtain the new inode key, and
** save the same lock information under it.
*/
key = dav_fs_build_fname_key(p, pathname);
if ((err = dav_fs_load_lock_record(lockdb, key, DAV_CREATE_LIST,
&ld, &id)) != NULL) {
/* ### insert a higher-level error description */
return err;
}
if ((err = dav_fs_save_lock_record(lockdb, key, NULL, NULL)) != NULL) {
/* ### insert a higher-level error description */
return err;
}
key = dav_fs_build_key(p, resource);
if ((err = dav_fs_save_lock_record(lockdb, key, ld, id)) != NULL) {
/* ### insert a higher-level error description */
return err;
}
}
#endif
return NULL;
}
static dav_error * dav_fs_create_lock(dav_lockdb *lockdb,
const dav_resource *resource,
dav_lock **lock)
{
dav_datum key;
key = dav_fs_build_key(lockdb->info->pool, resource);
*lock = dav_fs_alloc_lock(lockdb,
key,
NULL);
(*lock)->is_locknull = !resource->exists;
return NULL;
}
static dav_error * dav_fs_get_locks(dav_lockdb *lockdb,
const dav_resource *resource,
int calltype,
dav_lock **locks)
{
apr_pool_t *p = lockdb->info->pool;
dav_datum key;
dav_error *err;
dav_lock *lock = NULL;
dav_lock *newlock;
dav_lock_discovery *dp;
dav_lock_indirect *ip;
#if DAV_DEBUG
if (calltype == DAV_GETLOCKS_COMPLETE) {
return dav_new_error(lockdb->info->pool,
HTTP_INTERNAL_SERVER_ERROR, 0,
"INTERNAL DESIGN ERROR: DAV_GETLOCKS_COMPLETE "
"is not yet supported");
}
#endif
key = dav_fs_build_key(p, resource);
if ((err = dav_fs_load_lock_record(lockdb, key, DAV_CREATE_LIST,
&dp, &ip)) != NULL) {
/* ### push a higher-level desc? */
return err;
}
/* copy all direct locks to the result list */
for (; dp != NULL; dp = dp->next) {
newlock = dav_fs_alloc_lock(lockdb, key, dp->locktoken);
newlock->is_locknull = !resource->exists;
newlock->scope = dp->f.scope;
newlock->type = dp->f.type;
newlock->depth = dp->f.depth;
newlock->timeout = dp->f.timeout;
newlock->owner = dp->owner;
newlock->auth_user = dp->auth_user;
/* hook into the result list */
newlock->next = lock;
lock = newlock;
}
/* copy all the indirect locks to the result list. resolve as needed. */
for (; ip != NULL; ip = ip->next) {
newlock = dav_fs_alloc_lock(lockdb, ip->key, ip->locktoken);
newlock->is_locknull = !resource->exists;
if (calltype == DAV_GETLOCKS_RESOLVED) {
if ((err = dav_fs_resolve(lockdb, ip, &dp, NULL, NULL)) != NULL) {
/* ### push a higher-level desc? */
return err;
}
newlock->scope = dp->f.scope;
newlock->type = dp->f.type;
newlock->depth = dp->f.depth;
newlock->timeout = dp->f.timeout;
newlock->owner = dp->owner;
newlock->auth_user = dp->auth_user;
}
else {
/* DAV_GETLOCKS_PARTIAL */
newlock->rectype = DAV_LOCKREC_INDIRECT_PARTIAL;
}
/* hook into the result list */
newlock->next = lock;
lock = newlock;
}
*locks = lock;
return NULL;
}
static dav_error * dav_fs_find_lock(dav_lockdb *lockdb,
const dav_resource *resource,
const dav_locktoken *locktoken,
int partial_ok,
dav_lock **lock)
{
dav_error *err;
dav_datum key;
dav_lock_discovery *dp;
dav_lock_indirect *ip;
*lock = NULL;
key = dav_fs_build_key(lockdb->info->pool, resource);
if ((err = dav_fs_load_lock_record(lockdb, key, DAV_CREATE_LIST,
&dp, &ip)) != NULL) {
/* ### push a higher-level desc? */
return err;
}
for (; dp != NULL; dp = dp->next) {
if (!dav_compare_locktoken(locktoken, dp->locktoken)) {
*lock = dav_fs_alloc_lock(lockdb, key, locktoken);
(*lock)->is_locknull = !resource->exists;
(*lock)->scope = dp->f.scope;
(*lock)->type = dp->f.type;
(*lock)->depth = dp->f.depth;
(*lock)->timeout = dp->f.timeout;
(*lock)->owner = dp->owner;
(*lock)->auth_user = dp->auth_user;
return NULL;
}
}
for (; ip != NULL; ip = ip->next) {
if (!dav_compare_locktoken(locktoken, ip->locktoken)) {
*lock = dav_fs_alloc_lock(lockdb, ip->key, locktoken);
(*lock)->is_locknull = !resource->exists;
/* ### nobody uses the resolving right now! */
if (partial_ok) {
(*lock)->rectype = DAV_LOCKREC_INDIRECT_PARTIAL;
}
else {
(*lock)->rectype = DAV_LOCKREC_INDIRECT;
if ((err = dav_fs_resolve(lockdb, ip, &dp,
NULL, NULL)) != NULL) {
/* ### push a higher-level desc? */
return err;
}
(*lock)->scope = dp->f.scope;
(*lock)->type = dp->f.type;
(*lock)->depth = dp->f.depth;
(*lock)->timeout = dp->f.timeout;
(*lock)->owner = dp->owner;
(*lock)->auth_user = dp->auth_user;
}
return NULL;
}
}
return NULL;
}
static dav_error * dav_fs_has_locks(dav_lockdb *lockdb,
const dav_resource *resource,
int *locks_present)
{
dav_error *err;
dav_datum key;
*locks_present = 0;
if ((err = dav_fs_really_open_lockdb(lockdb)) != NULL) {
/* ### insert a higher-level error description */
return err;
}
/*
** If we opened readonly and the db wasn't there, then there are no
** locks for this resource. Just exit.
*/
if (lockdb->info->db == NULL)
return NULL;
key = dav_fs_build_key(lockdb->info->pool, resource);
*locks_present = (*dav_hooks_db_dbm.exists)(lockdb->info->db, key);
return NULL;
}
static dav_error * dav_fs_append_locks(dav_lockdb *lockdb,
const dav_resource *resource,
int make_indirect,
const dav_lock *lock)
{
apr_pool_t *p = lockdb->info->pool;
dav_error *err;
dav_lock_indirect *ip;
dav_lock_discovery *dp;
dav_datum key;
key = dav_fs_build_key(lockdb->info->pool, resource);
if ((err = dav_fs_load_lock_record(lockdb, key, 0, &dp, &ip)) != NULL) {
/* ### maybe add in a higher-level description */
return err;
}
/*
** ### when we store the lock more directly, we need to update
** ### lock->rectype and lock->is_locknull
*/
if (make_indirect) {
for (; lock != NULL; lock = lock->next) {
/* ### this works for any <lock> rectype */
dav_lock_indirect *newi = apr_pcalloc(p, sizeof(*newi));
/* ### shut off the const warning for now */
newi->locktoken = (dav_locktoken *)lock->locktoken;
newi->timeout = lock->timeout;
newi->key = lock->info->key;
newi->next = ip;
ip = newi;
}
}
else {
for (; lock != NULL; lock = lock->next) {
/* create and link in the right kind of lock */
if (lock->rectype == DAV_LOCKREC_DIRECT) {
dav_lock_discovery *newd = apr_pcalloc(p, sizeof(*newd));
newd->f.scope = lock->scope;
newd->f.type = lock->type;
newd->f.depth = lock->depth;
newd->f.timeout = lock->timeout;
/* ### shut off the const warning for now */
newd->locktoken = (dav_locktoken *)lock->locktoken;
newd->owner = lock->owner;
newd->auth_user = lock->auth_user;
newd->next = dp;
dp = newd;
}
else {
/* DAV_LOCKREC_INDIRECT(_PARTIAL) */
dav_lock_indirect *newi = apr_pcalloc(p, sizeof(*newi));
/* ### shut off the const warning for now */
newi->locktoken = (dav_locktoken *)lock->locktoken;
newi->key = lock->info->key;
newi->next = ip;
ip = newi;
}
}
}
if ((err = dav_fs_save_lock_record(lockdb, key, dp, ip)) != NULL) {
/* ### maybe add a higher-level description */
return err;
}
/* we have a special list for recording locknull resources */
/* ### ack! this can add two copies to the locknull list */
if (!resource->exists
&& (err = dav_fs_add_locknull_state(lockdb, resource)) != NULL) {
/* ### maybe add a higher-level description */
return err;
}
return NULL;
}
static dav_error * dav_fs_remove_lock(dav_lockdb *lockdb,
const dav_resource *resource,
const dav_locktoken *locktoken)
{
dav_error *err;
dav_buffer buf = { 0 };
dav_lock_discovery *dh = NULL;
dav_lock_indirect *ih = NULL;
dav_datum key;
key = dav_fs_build_key(lockdb->info->pool, resource);
if (locktoken != NULL) {
dav_lock_discovery *dp;
dav_lock_discovery *dprev = NULL;
dav_lock_indirect *ip;
dav_lock_indirect *iprev = NULL;
if ((err = dav_fs_load_lock_record(lockdb, key, DAV_CREATE_LIST,
&dh, &ih)) != NULL) {
/* ### maybe add a higher-level description */
return err;
}
for (dp = dh; dp != NULL; dp = dp->next) {
if (dav_compare_locktoken(locktoken, dp->locktoken) == 0) {
if (dprev)
dprev->next = dp->next;
else
dh = dh->next;
}
dprev = dp;
}
for (ip = ih; ip != NULL; ip = ip->next) {
if (dav_compare_locktoken(locktoken, ip->locktoken) == 0) {
if (iprev)
iprev->next = ip->next;
else
ih = ih->next;
}
iprev = ip;
}
}
/* save the modified locks, or remove all locks (dh=ih=NULL). */
if ((err = dav_fs_save_lock_record(lockdb, key, dh, ih)) != NULL) {
/* ### maybe add a higher-level description */
return err;
}
/*
** If this resource is a locknull resource AND no more locks exist,
** then remove the locknull member.
**
** Note: remove_locknull_state() attempts to convert a locknull member
** to a real member. In this case, all locks are gone, so the
** locknull resource returns to the null state (ie. doesn't exist),
** so there is no need to update the lockdb (and it won't find
** any because a precondition is that none exist).
*/
if (!resource->exists && dh == NULL && ih == NULL
&& (err = dav_fs_remove_locknull_member(lockdb->info->pool,
dav_fs_pathname(resource),
&buf)) != NULL) {
/* ### maybe add a higher-level description */
return err;
}
return NULL;
}
static int dav_fs_do_refresh(dav_lock_discovery *dp,
const dav_locktoken_list *ltl,
time_t new_time)
{
int dirty = 0;
for (; ltl != NULL; ltl = ltl->next) {
if (dav_compare_locktoken(dp->locktoken, ltl->locktoken) == 0)
{
dp->f.timeout = new_time;
dirty = 1;
}
}
return dirty;
}
static dav_error * dav_fs_refresh_locks(dav_lockdb *lockdb,
const dav_resource *resource,
const dav_locktoken_list *ltl,
time_t new_time,
dav_lock **locks)
{
dav_error *err;
dav_datum key;
dav_lock_discovery *dp;
dav_lock_discovery *dp_scan;
dav_lock_indirect *ip;
int dirty = 0;
dav_lock *newlock;
*locks = NULL;
key = dav_fs_build_key(lockdb->info->pool, resource);
if ((err = dav_fs_load_lock_record(lockdb, key, DAV_CREATE_LIST,
&dp, &ip)) != NULL) {
/* ### maybe add in a higher-level description */
return err;
}
/* ### we should be refreshing direct AND (resolved) indirect locks! */
/* refresh all of the direct locks on this resource */
for (dp_scan = dp; dp_scan != NULL; dp_scan = dp_scan->next) {
if (dav_fs_do_refresh(dp_scan, ltl, new_time)) {
/* the lock was refreshed. return the lock. */
newlock = dav_fs_alloc_lock(lockdb, key, dp_scan->locktoken);
newlock->is_locknull = !resource->exists;
newlock->scope = dp_scan->f.scope;
newlock->type = dp_scan->f.type;
newlock->depth = dp_scan->f.depth;
newlock->timeout = dp_scan->f.timeout;
newlock->owner = dp_scan->owner;
newlock->auth_user = dp_scan->auth_user;
newlock->next = *locks;
*locks = newlock;
dirty = 1;
}
}
/* if we refreshed any locks, then save them back. */
if (dirty
&& (err = dav_fs_save_lock_record(lockdb, key, dp, ip)) != NULL) {
/* ### maybe add in a higher-level description */
return err;
}
/* for each indirect lock, find its direct lock and refresh it. */
for (; ip != NULL; ip = ip->next) {
dav_lock_discovery *ref_dp;
dav_lock_indirect *ref_ip;
if ((err = dav_fs_resolve(lockdb, ip, &dp_scan,
&ref_dp, &ref_ip)) != NULL) {
/* ### push a higher-level desc? */
return err;
}
if (dav_fs_do_refresh(dp_scan, ltl, new_time)) {
/* the lock was refreshed. return the lock. */
newlock = dav_fs_alloc_lock(lockdb, ip->key, dp->locktoken);
newlock->is_locknull = !resource->exists;
newlock->scope = dp->f.scope;
newlock->type = dp->f.type;
newlock->depth = dp->f.depth;
newlock->timeout = dp->f.timeout;
newlock->owner = dp->owner;
newlock->auth_user = dp_scan->auth_user;
newlock->next = *locks;
*locks = newlock;
/* save the (resolved) direct lock back */
if ((err = dav_fs_save_lock_record(lockdb, ip->key, ref_dp,
ref_ip)) != NULL) {
/* ### push a higher-level desc? */
return err;
}
}
}
return NULL;
}
const dav_hooks_locks dav_hooks_locks_fs =
{
dav_fs_get_supportedlock,
dav_fs_parse_locktoken,
dav_fs_format_locktoken,
dav_fs_compare_locktoken,
dav_fs_open_lockdb,
dav_fs_close_lockdb,
dav_fs_remove_locknull_state,
dav_fs_create_lock,
dav_fs_get_locks,
dav_fs_find_lock,
dav_fs_has_locks,
dav_fs_append_locks,
dav_fs_remove_lock,
dav_fs_refresh_locks,
NULL, /* get_resource */
};