props.c

Go to the documentation of this file.

/************************************************************************
 * Copyright (C) 2007-2009 Philipp Marek.
 *
 * This program is free software;  you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3 as
 * published by the Free Software Foundation.
 ************************************************************************/


#include <sys/types.h>
#include <limits.h>
#include <unistd.h>
#include <gdbm.h>
#include <fcntl.h>
#include <subversion-1/svn_props.h>

#include "global.h"
#include "waa.h"
#include "url.h"
#include "helper.h"
#include "actions.h"
#include "hash_ops.h"
#include "props.h"
#include "update.h"
#include "ignore.h"
#include "est_ops.h"
#include "add_unvers.h"
#include "warnings.h"


 /* TODO: If you use \c - as the value, the value is read from \c STDIN. */
#define FSVS_PROP_PREFIX "fsvs:"

#define FSVS_PROP_COMMIT_PIPE FSVS_PROP_PREFIX "commit-pipe"

#define FSVS_PROP_UPDATE_PIPE FSVS_PROP_PREFIX "update-pipe"

#define FSVS_PROP_INSTALL_CMD FSVS_PROP_PREFIX "install"


#define FSVS_PROP_ORIG_MD5 FSVS_PROP_PREFIX "original-md5"

#ifndef SVN_PROP_TEXT_TIME
#define SVN_PROP_TEXT_TIME  SVN_PROP_PREFIX "text-time"
#endif
#ifndef SVN_PROP_OWNER
#define SVN_PROP_OWNER SVN_PROP_PREFIX "owner"
#endif
#ifndef SVN_PROP_GROUP
#define SVN_PROP_GROUP  SVN_PROP_PREFIX "group"
#endif
#ifndef SVN_PROP_UNIX_MODE
#define SVN_PROP_UNIX_MODE  SVN_PROP_PREFIX "unix-mode"
#endif

char propname_mtime[]=SVN_PROP_TEXT_TIME,
         propname_owner[]=SVN_PROP_OWNER,
         propname_group[]=SVN_PROP_GROUP,
         propname_origmd5[]=FSVS_PROP_ORIG_MD5,
         propname_umode[]=SVN_PROP_UNIX_MODE,
         propname_special[]=SVN_PROP_SPECIAL,
         propval_special []=SVN_PROP_SPECIAL_VALUE,

         propval_commitpipe[]=FSVS_PROP_COMMIT_PIPE,
         propval_updatepipe[]=FSVS_PROP_UPDATE_PIPE,
         propval_orig_md5  []=FSVS_PROP_ORIG_MD5;
const char prp___to_be_removed_value[]=
    "FSVS:INTERNAL-\nto-be-removed\n-"
    "\x8f\xc1\xa6\xe5\x86\x0a\x01\x72\x54\x89\x25\x23\x03\xc3\xfa\x75";



int prp__open_byname(char *wcfile, int gdbm_mode, hash_t *db)
{
  int status;
    
    status=hsh__new(wcfile, WAA__PROP_EXT, gdbm_mode, db);
    if (status != ENOENT)
        STOPIF(status, "Opening property file for %s", wcfile);

ex:
    return status;
}


int prp__open_byestat(struct estat *sts, int gdbm_mode, hash_t *db)
{
    int status;
    char *fn;

    STOPIF( ops__build_path(&fn, sts), NULL);
    status=prp__open_byname(fn, gdbm_mode, db);
    if (status != ENOENT) STOPIF(status, NULL);

ex:
    return status;
}


int prp__set(hash_t db, 
        const char *name, 
        const char *data, int datalen)
{
    int status;
    datum key, value;

    key.dptr=(char*)name;
    key.dsize=strlen(name)+1;

    if (data)
    {
        value.dptr=(char*)data;
        value.dsize=datalen;

        if (datalen == -1)
            value.dsize= *data ? strlen(data)+1 : 0;
#ifdef ENABLE_DEBUG
        else
            BUG_ON(value.dptr[value.dsize-1] != 0, "Not terminated!");
#endif
    }
    else
    {
        value.dptr=NULL;
        value.dsize=0;
    }

    STOPIF( prp__store(db, key, value), NULL);

ex:
    return status;
}


int prp__set_svnstr(hash_t db, 
        const char *name, 
        const svn_string_t *utf8_value)
{
    return prp__set(db, name, utf8_value->data, utf8_value->len+1);
}


int prp__store(hash_t db, datum key, datum value)
{
    int status;

    DEBUGP("storing property %s=%s", key.dptr, value.dptr);
    STOPIF( hsh__store(db, key, value), NULL);
ex:
    return status;
}


int prp__get(hash_t db, char *keycp, datum *value)
{
  static datum key;

    key.dptr=keycp;
    key.dsize=strlen(keycp)+1;
    return prp__fetch(db, key, value);
}


int prp__set_from_aprhash(struct estat *sts, 
        apr_hash_t *props, 
        enum prp__set_from_aprhash_e flags,
        hash_t *props_db,
        apr_pool_t *pool)
{
    int status;
    apr_hash_index_t *hi;
    char *prop_key;
    apr_ssize_t prop_key_len;
    
    svn_string_t *prop_val;
    hash_t db;
    int to_store, count;
    void *k, *v;


    status=0;
    count=0;

    /* The old behaviour was to always open the database file. If no 
     * user-specified properties are given, old properties were removed that 
     * way.
     * But gdbm has the problem that on gdbm_close() a fsync() is done - even 
     * if nothing was written; this means that for every updated file we 
     * create a new property database, write nothing in it, do a fsync(), 
     * close it, and delete it again - which costs some time.
     *
     * Debian bug #514704.
     *
     * (Removing of old properties is needed because we'd only know in 
     * cb__record_changes() that properties get removed; in revert we only 
     * have the new list.
     * TODO: Merge local and remote changes.) */
    /* We remember the filename, so that empty hashes get removed on close.  
     * */
    db=NULL;
    hi=apr_hash_first(pool, props);

    if (flags & STORE_IN_FS)
    {
        /* If we want to write the data to disk, but there is nothing to write 
         * (and the caller doesn't need the DB), just remove the file. See 
         * above.  */
        if (!hi && !props_db)
        {
            STOPIF( prp__unlink_db_for_estat(sts), NULL);
            goto ex;
        }

        STOPIF( prp__open_byestat(sts, 
                    GDBM_NEWDB | HASH_REMEMBER_FILENAME, &db), NULL);
    }

    for (; hi; hi = apr_hash_next(hi)) 
    {
        /* As the name/key is a (char*), we don't need its length. */
        /* Is there a cleaner way than this (cast or compiler warning)??
         * subversion defines a "const void * key" and casts that to 
         * whatever needed in subsequent calls - which isn't pretty, too. */
        k=&prop_key;
        v=&prop_val;
        apr_hash_this(hi, k, &prop_key_len, v);

        to_store=0;
        STOPIF( up__parse_prop(sts, prop_key, prop_val, 
                    &to_store, pool), NULL);

        if (to_store)
        {
            if (db)
            {
                STOPIF( prp__set_svnstr(db, prop_key, prop_val), NULL);
            }
            count++;
        }
        else
        {
            /* If already used it's no longer needed. */
            if (flags & ONLY_KEEP_USERDEF)
                apr_hash_set(props, prop_key, prop_key_len, NULL);
        }
    }

    DEBUGP("%d properties stored", count);
    if (props_db)
        *props_db=db;
    else
        STOPIF( hsh__close(db, status), NULL);

ex:
    return status;
}


int prp__g_work(struct estat *root, int argc, char *argv[])
{
    int status, st2;
    datum key, value;
    hash_t db;
    FILE *output;
    char **normalized;


    status=0;
    output=stdout;
    if (argc<2) ac__Usage_this();


    key.dptr=*(argv++);
    key.dsize=strlen(key.dptr)+1;
    argc--;


    STOPIF( waa__find_common_base(argc, argv, &normalized), NULL);


    for(; *argv; argv++)
    {
        db=NULL;
        status=prp__open_byname( *normalized, GDBM_READER, &db);
        if (!status)
            status=prp__fetch(db, key, &value);

        if (status == ENOENT)
        {
            DEBUGP("No such property");
        }
        else if (status)
        {
            /* Any other error means trouble. */
            STOPIF( status, NULL);
        }
        else if (value.dptr && !prp__prop_will_be_removed(value))
        {
            STOPIF_CODE_EPIPE( fputs(value.dptr, output), NULL);
            STOPIF_CODE_EPIPE( fputc('\n', output), NULL);
        }

        if (db)
            STOPIF( hsh__close(db, status), NULL);
        db=NULL;
    }

    status=0;

ex:
    if (db)
    {
        st2=hsh__close(db, status);
        db=NULL;
        if (!status && st2)
            STOPIF( st2, NULL);
    }
    return status;
}


int prp__s_work(struct estat *root, int argc, char *argv[])
{
    int status, st2;
    datum key, value, rv;
    hash_t db;
    char **normalized;
    struct estat *sts;
    int change;


    status=0;
    if (argc<2) ac__Usage_this();

    /* Check name for special values. */
    if (svn_prop_is_svn_prop(*argv))
        STOPIF( wa__warn( WRN__PROP_NAME_RESERVED, EINVAL, 
                    "This is a reserved property name and should not be used." ), 
                NULL );


    key.dptr=*(argv++);
    key.dsize=strlen(key.dptr)+1;
    argc--;

    if (action->i_val == FS_REMOVED)
    {
        value.dptr=(char*)prp___to_be_removed_value;
        /* + \0 */
        value.dsize=strlen(prp___to_be_removed_value)+1;
    }
    else
    {
        value.dptr=*(argv++);
        value.dsize=strlen(value.dptr)+1;
        argc--;
        if (argc<1) ac__Usage_this();
    }


    STOPIF( waa__find_common_base(argc, argv, &normalized), NULL);

    STOPIF( au__prepare_for_added(), NULL);

    STOPIF( waa__input_tree(root, NULL, NULL), NULL);


    for(; *normalized; normalized++)
    {
        STOPIF( ops__traverse(root, *normalized, 
                    OPS__CREATE | OPS__FAIL_NOT_LIST, RF_ADD, &sts), NULL);

        if (sts->flags & RF_ISNEW)
        {
            /* Get group. */
            STOPIF( ign__is_ignore(sts, &change), NULL);
            STOPIF( ops__apply_group(sts, &db, NULL), NULL);

            if (!sts->url)
                sts->url=current_url;

            STOPIF( hlp__lstat( *normalized, & sts->st),
                    "!'%s' can not be queried", *normalized);
            /* Such entries must be set as added, if needed - else they wouldn't be 
             * seen as new.  */
            sts->flags |= RF_ADD;
        }
        else
            STOPIF( prp__open_byestat(sts, GDBM_WRCREAT, &db), NULL);


        /* Check if modified. */
        change=0;
        status=prp__fetch(db, key, &rv);
        if (action->i_val == FS_REMOVED)
        {
            if (status == ENOENT) 
                DEBUGP("%s on %s didnt exist anyway", key.dptr, *normalized);
            else
                change++;
        }
        else
        {
            if (status == ENOENT)
                change++;
            else
            {
                change = (rv.dsize != value.dsize) ||
                    memcmp(rv.dptr, value.dptr, value.dsize) != 0;
                DEBUGP("%s on %s change? %d", key.dptr, *normalized, change);
            }
        }

        if (change)
        {
            STOPIF( prp__store(db, key, value), NULL);
            sts->flags |= RF_PUSHPROPS;
        }

        STOPIF( hsh__close(db, status), NULL);
        db=NULL;
    }

    STOPIF( waa__output_tree(root), NULL);

ex:
    if (db)
    {
        st2=hsh__close(db, status);
        db=NULL;
        if (!status && st2)
            STOPIF( st2, NULL);
    }
    return status;
}


int prp__open_get_close(struct estat *sts, char *name, 
        char **data, int *len)
{
    int status;
    hash_t props;
    datum value;

    props=NULL;

    status=prp__open_byestat(sts, GDBM_READER, &props);
    if (status == ENOENT) goto ex;
    STOPIF(status, NULL);

    status=prp__get(props, name, &value);
    if (status == ENOENT) goto ex;
    STOPIF(status, NULL);

    if (len) *len=value.dsize;
    if (data) *data=value.dptr;
    else IF_FREE(value.dptr);

ex:
    if (props)
        hsh__close(props, status);
    return status;
}


int prp__l_work(struct estat *root, int argc, char *argv[])
{
    int status, count;
    int many_files;
    char indent[5]="    ";
    hash_t db;
    FILE *output;
    datum key, data;
    char **normalized;


    status=0;
    db=NULL;
    if (!argc) ac__Usage_this();


    STOPIF( waa__find_common_base(argc, argv, &normalized), NULL);


    output=stdout;
    many_files= argc>1;
    if (!many_files) *indent=0;

    for(; *normalized; normalized++)
    {
        status=prp__open_byname( *normalized, GDBM_READER, &db);
        if (status == ENOENT) goto noprops;

        if (status)
            STOPIF(status, "Cannot open properties file for '%s'",
                    *normalized);


        count=0;
        status=prp__first(db, &key);
        while (status == 0)
        {
            DEBUGP("got key with len=%d: %.30s", key.dsize, key.dptr);

            STOPIF( prp__fetch(db, key, &data), NULL);
            if (prp__prop_will_be_removed(data))
            {
                /* This property will be removed on next commit. */
            }
            else
            {
                count++;

                if (count==1 && many_files)
                    STOPIF_CODE_EPIPE( printf("Properties of %s:\n", *normalized), NULL);

                STOPIF_CODE_EPIPE( fputs(indent, output), NULL);
                /* The key and value are defined to have a \0 at the end.
                 * This should not be printed. */
                STOPIF( hlp__safe_print(output, key.dptr, key.dsize-1), NULL);

                if (opt__is_verbose() > 0)
                {
                    STOPIF_CODE_EPIPE( fputc('=',output), NULL);
                    STOPIF( hlp__safe_print(output, data.dptr, data.dsize-1), NULL);

                    free(data.dptr);
                }

                STOPIF_CODE_EPIPE( fputc('\n', output), NULL);
            }

            status=prp__next(db, &key, &key);
        }

        if (count == 0)
        {
noprops:
            printf("%s has no properties.\n", *normalized);
            status=0;
            continue;
        }


        STOPIF( hsh__close(db, status), NULL);
        db=NULL;
    }

ex:
    hsh__close(db, status);
    return status;
}


int prp__unlink_db_for_estat(struct estat *sts)
{
    int status;
    char *cp, *eos, *path;

    STOPIF( ops__build_path(&path, sts), NULL);

    STOPIF( waa__get_waa_directory(path, &cp, &eos, NULL,
                waa__get_gwd_flag(WAA__PROP_EXT)), NULL);
    strcpy(eos, WAA__PROP_EXT);

    status= unlink(cp) == -1 ? errno : 0;
    if (status == ENOENT)
        status=0;
    else STOPIF(status, "deleting properties of %s (%s)", path, cp);

ex:
    return status;
}

---