static void dav_propdb_close(dav_db *db)
{
if (db->ns_table_dirty) {
dav_propdb_metadata m;
apr_datum_t key;
apr_datum_t value;
dav_error *err;
key.dptr = DAV_GDBM_NS_KEY;
key.dsize = DAV_GDBM_NS_KEY_LEN;
value.dptr = db->ns_table.buf;
value.dsize = db->ns_table.cur_len;
/* fill in the metadata that we store into the prop db. */
m.major = DAV_DBVSN_MAJOR;
m.minor = db->version; /* ### keep current minor version? */
m.ns_count = htons(db->ns_count);
memcpy(db->ns_table.buf, &m, sizeof(m));
err = dav_dbm_store(db, key, value);
/* ### what to do with the error? */
}
dav_dbm_close(db);
}
static void dav_propdb_close(dav_db *db)
{
if (db->ns_table_dirty) {
dav_propdb_metadata m;
apr_datum_t key;
apr_datum_t value;
dav_error *err;
key.dptr = DAV_GDBM_NS_KEY;
key.dsize = DAV_GDBM_NS_KEY_LEN;
value.dptr = db->ns_table.buf;
value.dsize = db->ns_table.cur_len;
/* fill in the metadata that we store into the prop db. */
m.major = DAV_DBVSN_MAJOR;
m.minor = db->version; /* ### keep current minor version? */
m.ns_count = htons(db->ns_count);
memcpy(db->ns_table.buf, &m, sizeof(m));
err = dav_dbm_store(db, key, value);
if (err != NULL)
ap_log_error(APLOG_MARK, APLOG_WARNING, err->aprerr, ap_server_conf,
APLOGNO(00577) "Error writing propdb: %s", err->desc);
}
dav_dbm_close(db);
}
static dav_error * dav_propdb_apply_rollback(dav_db *db,
dav_deadprop_rollback *rollback)
{
if (rollback->value.dptr == NULL) {
/* don't fail if the thing isn't really there. */
(void) dav_dbm_delete(db, rollback->key);
return NULL;
}
return dav_dbm_store(db, rollback->key, rollback->value);
}
static dav_error * dav_propdb_store(dav_db *db, const dav_prop_name *name,
const apr_xml_elem *elem,
dav_namespace_map *mapping)
{
apr_datum_t key = dav_build_key(db, name);
apr_datum_t value;
/* Note: mapping->ns_map was set up in dav_propdb_map_namespaces() */
/* ### use a db- subpool for these values? clear on exit? */
/* quote all the values in the element */
/* ### be nice to do this without affecting the element itself */
/* ### of course, the cast indicates Badness is occurring here */
apr_xml_quote_elem(db->pool, (apr_xml_elem *)elem);
/* generate a text blob for the xml:lang plus the contents */
apr_xml_to_text(db->pool, elem, APR_XML_X2T_LANG_INNER, NULL,
mapping->ns_map,
(const char **)&value.dptr, &value.dsize);
return dav_dbm_store(db, key, value);
}
/*
** 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, apr_datum_t key,
dav_lock_discovery *direct,
dav_lock_indirect *indirect)
{
dav_error *err;
apr_datum_t 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, 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_dbm_delete(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_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;
}
