global.h

Go to the documentation of this file.

/************************************************************************
 * Copyright (C) 2005-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.
 ************************************************************************/

#ifndef __GLOBAL_H__
#define __GLOBAL_H__

#include "config.h"
#include "preproc.h"

#include <sys/stat.h>
#include <sys/types.h>
#include <gdbm.h>
#include <stddef.h>
#include <sys/types.h>
#include <apr_md5.h>
#include <apr_file_io.h>
#include <subversion-1/svn_ra.h>
#include <subversion-1/svn_string.h>
#include <pcre.h>


#define IF_FREE(x) do { if (x) free(x); x=NULL; } while (0)

/* \addtogroup compati */
/* @{ */
#define PATH_SEPARATOR ('/')

#define ENVIRONMENT_START ('$')

#define UNUSED __attribute__  ((__unused__))


typedef unsigned char md5_digest_t[APR_MD5_DIGESTSIZE];



typedef unsigned long long t_ull;
typedef long long t_ll;
typedef unsigned long t_ul;
#define PT_SHELL (1)
#define PT_PCRE (2)
#define PT_DEVICE (3)
#define PT_INODE (4)
#define PT_SHELL_ABS (5)

struct ignore_t {
    char *pattern;

    const char *group_name;
    struct grouping_t *group_def;

    char *compare_string;

    unsigned stats_tested;
    unsigned stats_matches;

    union {
        /* for shell and pcre */
        struct {
            pcre *compiled;
            pcre_extra *extra;
        };

        struct {
            int major;
            int minor;
            char compare;
            char has_minor;
        };

        struct {
            ino_t inode;
            dev_t dev;
        };
    };

    unsigned short mode_match_and;
    unsigned short mode_match_cmp;

    unsigned int dir_only:1;
    unsigned int is_icase:1;
    unsigned int is_user_pat:1;

    /* This is at the end because of alignment issues. */
    unsigned int type:3;
};

#define PAT_DEV__UNSPECIFIED (0)
#define PAT_DEV__LESS (1)
#define PAT_DEV__EQUAL (2)
#define PAT_DEV__GREATER (4)
#define PAT_DEV___INVALID_MASK (PAT_DEV__LESS | PAT_DEV__GREATER)
#define PAT_DEV__HAVE_MINOR (0x80)

#define INVALID_INTERNAL_NUMBER (-1)

struct url_t {
    char *url;
    int priority; 
    int urllen;
    svn_revnum_t target_rev;
    svn_revnum_t current_target_rev;
    svn_revnum_t current_rev;
    svn_revnum_t head_rev;
    char *name;
    int internal_number;
    unsigned count;
    svn_ra_session_t *session;
    apr_pool_t *pool;

    int entry_list_count;

    int to_be_handled:1;
    int current_target_override:1;
    unsigned is_readonly:1;
};


/* We may not use the st_ names, as some have #defined names. */
/* On my system these are all either 64bit or 32bit types, so there's
 * no alignment problem (which would arise if there was eg. a 16bit type,
 * then space would be wasted) */
struct sstat_t {
    /* For easier comparison, we overlay an 64bit type. */
    union {
        struct timespec mtim;
        unsigned long long _mtime;
    };
    union {
        struct timespec ctim;
        unsigned long long _ctime;
    };

    union {
        off_t   size;
        dev_t rdev;
    };

    dev_t dev;
    ino_t ino;

    mode_t mode;

    uid_t uid;
    gid_t gid;
};



struct estat {
    struct estat *parent;
    char *name;

    struct sstat_t st;

    svn_revnum_t repos_rev;
    svn_revnum_t old_rev;

    struct url_t *url;

    struct estat *old;

    union {
        struct {
            char *decoder;
            md5_digest_t md5;
            unsigned int has_orig_md5:1;
            unsigned int change_flag:2;
        };
        struct {
            char *strings;
            struct estat **by_inode;
            struct estat **by_name;

            AC_CV_C_UINT32_T entry_count;

            AC_CV_C_UINT32_T unfinished;

            unsigned int other_revs:1;
            unsigned int to_be_sorted:1;
            /* Currently unused - see ignore.c. */
#if 0
            struct ignore_t **active_ign;
            struct ignore_t **subdir_ign;
#endif
        };
    };

    union {
        struct {
            void *baton;
        };
        struct {
            apr_pool_t *filehandle_pool;
        };
        struct {
            svn_stringbuf_t *stringbuf_tgt;
        };
        struct {
            AC_CV_C_UINT32_T child_index;
        };
        struct {
            AC_CV_C_UINT32_T file_index;
        };
    };


    char *arg;

    struct ignore_t *match_pattern;

  apr_hash_t *user_prop;

    AC_CV_C_UINT32_T flags;


    unsigned old_rev_mode_packed:PACKED_MODE_T_NEEDED_BITS;
    unsigned new_rev_mode_packed:PACKED_MODE_T_NEEDED_BITS;
    unsigned local_mode_packed:PACKED_MODE_T_NEEDED_BITS;
    unsigned int entry_status:10;

    unsigned int remote_status:10;


    unsigned int cache_index:6;


    unsigned short path_len:16;

    unsigned int was_output:1;
    unsigned int decoder_is_correct:1;

    unsigned int do_userselected:1;
    unsigned int do_child_wanted:1;
    unsigned int do_this_entry:1;
    unsigned int do_filter_allows:1;
    unsigned int do_filter_allows_done:1;

    unsigned int to_be_ignored:1;
};


#define S_IFUNDEF (0)

#define S_IFANYSPECIAL S_IFSOCK
#define S_ISANYSPECIAL S_ISSOCK

#define S_IFGARBAGE S_IFIFO
#define S_ISGARBAGE S_ISFIFO

#define RF_UNVERSION (1)

#define RF_ADD (2)

#define RF_CHECK (4)

#define RF_PUSHPROPS (8)

#define RF_COPY_BASE (16)

#define RF_COPY_SUB (32)

#define RF_CONFLICT (64)

#define RF_DONT_WRITE (1 << 18)

#define RF_ISNEW (1 << 19)

#define RF_PRINT (1 << 20)

#define RF___SAVE_MASK (RF_UNVERSION | RF_ADD | RF_CHECK | \
        RF_COPY_BASE | RF_COPY_SUB | RF_PUSHPROPS | RF_CONFLICT)

#define RF___COMMIT_MASK (RF_UNVERSION | RF_ADD | RF_COPY_BASE | RF_PUSHPROPS)
#define RF___IS_COPY (RF_COPY_BASE | RF_COPY_SUB)



#define FS_NO_CHANGE (0)
#define FS_NEW (1 << 0)
#define FS_REMOVED (1 << 1)
#define FS_CHANGED (1 << 2)

#define FS_LIKELY (1 << 3)
#define FS_REPLACED (FS_NEW | FS_REMOVED)

#define FS_PROPERTIES (1 << 4)


#define FS_META_MTIME (1 << 5)
#define FS_META_OWNER (1 << 6)
#define FS_META_GROUP (1 << 7)
#define FS_META_UMODE (1 << 8)

#define FS_META_CHANGED (FS_META_MTIME | FS_META_OWNER | \
        FS_META_GROUP | FS_META_UMODE)

#define FS_CHILD_CHANGED (1 << 9)

#define FS__CHANGE_MASK (FS_NEW | FS_REMOVED | FS_CHANGED | \
        FS_META_CHANGED | FS_PROPERTIES)

#define CF_UNKNOWN (0)
#define CF_CHANGED (1)
#define CF_NOTCHANGED (2)

#define OPS__CREATE (1)

#define OPS__ON_UPD_LIST (2)

#define OPS__FAIL_NOT_LIST (4)

#define OPS__FAIL_NOT_FS (16)



#ifdef ENABLE_RELEASE
#define DEBUGP(...) do { } while (0)
#else

extern void _DEBUGP(const char *file, int line, const char *func, char *format, ...)
    __attribute__ ((format (printf, 4, 5) ));
#define DEBUGP(...) do { if (debuglevel) _DEBUGP(__FILE__, __LINE__, __PRETTY_FUNCTION__, __VA_ARGS__); } while (0)
#endif


    extern int make_STOP_silent;
extern int _STOP(const char *file, int line, const char *function,
        int errl, const char *format, ...)
__attribute__ ((format (printf, 5, 6) ));
#define STOPIF_FULLPARM(cond, status, code, go, ... ) \
    do                                                  \
{                                                   \
    if (cond)                                         \
    {                                                 \
        status=code;                                                                        \
        _STOP(__FILE__, __LINE__, __PRETTY_FUNCTION__, code, __VA_ARGS__);   \
        goto go;                                        \
    }                                                 \
} while (0)

#define STOPIF_CODE_ERR_GOTO(cond, code, ex, ... ) STOPIF_FULLPARM(cond, status, code, ex, __VA_ARGS__)

#define STOPIF_CODE_ERR(cond, code, ... ) STOPIF_CODE_ERR_GOTO(cond, code, ex, __VA_ARGS__)
/* Main error call macro.
 * This is the macro that should be used for all internal function calls.
 * \param code The status code to check.
 * All other things are hardcoded. */
#define STOPIF(code, ... ) \
    do                                                \
{                                                   \
    status=(code);                                    \
    if (status)                                                         \
    {                                                                                                   \
        _STOP(__FILE__, __LINE__, __PRETTY_FUNCTION__, status, __VA_ARGS__);   \
        goto ex;                                        \
    }                                                                                                   \
} while (0)

#define STOPIF_ENOMEM(cond) STOPIF_CODE_ERR(cond, ENOMEM, NULL)

#define STOPIF_CODE_EPIPE(code, ...) \
    do                                                   \
{                                                      \
    if ((code) < 0)                                      \
    {                                                    \
        status=errno;                                      \
        if (status == EPIPE) status= -EPIPE;               \
        STOPIF(status, "Error writing output");          \
    }                                                    \
} while (0)

#define STOPIF_SVNERR_TEXT(func, parm, fmt, ...)          \
    do                                                       \
{                                                          \
    status_svn=func parm;                                    \
    STOPIF_CODE_ERR( status_svn, status_svn->apr_err,   \
            fmt ": %s", ## __VA_ARGS__, status_svn->message);  \
} while (0)
/* The mainly used function wrapper.
 * \param func Name of the subversion function
 * \param parm A parenthesized list of arguments.
 * \code
 *   STOPIF_SVNERR( svn_ra_initialize, (global_pool));
 * \endcode
 */
#define STOPIF_SVNERR(func, parm) STOPIF_SVNERR_TEXT(func, parm, #func)

#define STOP_HANDLE_SVNERR(svnerr) STOPIF_CODE_ERR_GOTO(svnerr, svnerr->apr_err, ex2, (const char*)svnerr->message)

#define RETURN_SVNERR(status) return status ?               \
    svn_error_create (status, NULL,                                     \
            __PRETTY_FUNCTION__) : SVN_NO_ERROR;


#define BUG(...) do { fflush(NULL); debuglevel=1; DEBUGP(__VA_ARGS__); *(int*)42=__LINE__; } while (0)

#define BUG_ON(cond, ...) do { if (cond) BUG( "INTERNAL BUG\n  " #cond "\n  " __VA_ARGS__); } while (0)

#define VALGRIND_MAKE_MEM_NOACCESS(_qzz_addr,_qzz_len) do { } while(0)
#define VALGRIND_MAKE_MEM_UNDEFINED(_qzz_addr,_qzz_len) do { } while(0)
#define VALGRIND_MAKE_MEM_DEFINED(_qzz_addr,_qzz_len) do { } while(0)

#ifdef ENABLE_DEBUG
#ifdef HAVE_VALGRIND
#undef VALGRIND_MAKE_MEM_DEFINED
#undef VALGRIND_MAKE_MEM_UNDEFINED
#undef VALGRIND_MAKE_MEM_NOACCESS
#include <valgrind/memcheck.h>
#endif
#endif

extern int opt_recursive;
extern int is_import_export;
extern int debuglevel;

extern char *opt_commitmsg;
extern char *opt_commitmsgfile;

extern svn_revnum_t target_revision;
extern svn_revnum_t opt_target_revision;
extern svn_revnum_t opt_target_revision2;
extern int opt_target_revisions_given;

#ifdef HAVE_LOCALES
extern char *local_codeset;
#endif

extern svn_ra_session_t *session;

extern apr_pool_t *global_pool;

extern struct url_t **urllist;
extern int urllist_count;
extern struct url_t *current_url;

extern unsigned approx_entry_count;
extern char propname_mtime[];
extern char propname_owner[];
extern char propname_group[];
extern char propname_umode[];
extern char propname_origmd5[];
extern char propname_special[];
extern char propval_special[];

extern char propval_commitpipe[];
extern char propval_updatepipe[];


extern char parm_dump[],
             parm_test[],
             parm_load[];
extern char *start_path;
extern int start_path_len;

#define ANSI__BLUE "\x1b[1;34m"
#define ANSI__GREEN "\x1b[1;32m"
#define ANSI__RED "\x1b[1;31m"
#define ANSI__WHITE "\x1b[1;37m"
#define ANSI__NORMAL "\x1b[0;0m"

extern char **environ;

#endif

---