misc.h

/* createrepo_c - Library of routines for manipulation with repodata
 * Copyright (C) 2012  Tomas Mlcoch
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 * USA.
 */

#ifndef __C_CREATEREPOLIB_MISC_H__
#define __C_CREATEREPOLIB_MISC_H__

#ifdef __cplusplus
extern "C" {
#endif

#include <glib.h>
#include <string.h>
#include <curl/curl.h>
#include "compression_wrapper.h"
#include "xml_parser.h"

#define CR_STATICSTRLEN(s) (sizeof(s)/sizeof(s[0]))

/* Length of static defined array.
 */
#define CR_ARRAYLEN(x) ((sizeof(x)/sizeof(0[x])) / ((size_t)(!(sizeof(x) % sizeof(0[x])))))

const char *cr_flag_to_str(gint64 flags);

typedef struct {
    char *epoch;        
    char *version;      
    char *release;      
} cr_EVR;

typedef struct {
    char *name;
    char *epoch;
    char *version;
    char *release;
} cr_NEVR;

typedef struct {
    char *name;
    char *epoch;
    char *version;
    char *release;
    char *arch;
} cr_NEVRA;

struct cr_Version {
    long major;         
    long minor;         
    long patch;         
    char *suffix;       
};


cr_EVR *cr_str_to_evr(const char *string, GStringChunk *chunk);

void
cr_evr_free(cr_EVR *evr);

static inline int cr_is_primary(const char *filename) {
    if (!strncmp(filename, "/etc/", 5))
        return 1;
    if (!strcmp(filename, "/usr/lib/sendmail"))
        return 1;
    if (strstr(filename, "bin/"))
        return 1;
    return 0;
};

struct cr_HeaderRangeStruct {
    unsigned int start;         
    unsigned int end;           
};

struct cr_HeaderRangeStruct cr_get_header_byte_range(const char *filename,
                                                     GError **err);

char *cr_get_filename(const char *filepath);

int cr_download(CURL *handle,
                const char *url,
                const char *destination,
                GError **err);

gboolean cr_copy_file(const char *src,
                      const char *dst,
                      GError **err);

#define cr_compress_file(SRC, DST, COMTYPE, ERR) \
                    cr_compress_file_with_stat(SRC, DST, COMTYPE, NULL, ERR)

int cr_compress_file_with_stat(const char *src,
                               const char *dst,
                               cr_CompressionType comtype,
                               cr_ContentStat *stat,
                               GError **err);

#define cr_decompress_file(SRC, DST, COMTYPE, ERR) \
                    cr_decompress_file_with_stat(SRC, DST, COMTYPE, NULL, ERR)

int cr_decompress_file_with_stat(const char *src,
                                 const char *dst,
                                 cr_CompressionType comtype,
                                 cr_ContentStat *stat,
                                 GError **err);

gboolean cr_better_copy_file(const char *src,
                             const char *dst,
                             GError **err);

int cr_remove_dir(const char *path, GError **err);

char *cr_normalize_dir_path(const char *path);

struct cr_Version cr_str_to_version(const char *str);

int cr_cmp_version_str(const char* str1, const char *str2);

void cr_null_log_fn(const gchar *log_domain,
                    GLogLevelFlags log_level,
                    const gchar *message,
                    gpointer user_data);

void cr_log_fn(const gchar *log_domain,
               GLogLevelFlags log_level,
               const gchar *message,
               gpointer user_data);

void cr_slist_free_full(GSList *list, GDestroyNotify free_f);

void cr_queue_free_full(GQueue *queue, GDestroyNotify free_f);

cr_NEVRA *cr_split_rpm_filename(const char *filename);

#define cr_cmp_nevra(A, B) (cr_cmp_evr((A)->epoch, (A)->version, (A)->release,\
                                        (B)->epoch, (B)->version, (B)->release))

int cr_cmp_evr(const char *e1, const char *v1, const char *r1,
               const char *e2, const char *v2, const char *r2);


static inline gchar *
cr_safe_string_chunk_insert(GStringChunk *chunk, const char *str)
{
    if (!str) return NULL;
    return g_string_chunk_insert(chunk, str);
}

static inline gchar *
cr_safe_string_chunk_insert_and_free(GStringChunk *chunk, char *str)
{
    if (!str) return NULL;
    gchar *copy = g_string_chunk_insert(chunk, str);
    g_free(str);
    return copy;
}

static inline gchar *
cr_safe_string_chunk_insert_null(GStringChunk *chunk, const char *str)
{
    if (!str || *str == '\0') return NULL;
    return g_string_chunk_insert(chunk, str);
}


static inline gchar *
cr_safe_string_chunk_insert_const(GStringChunk *chunk, const char *str)
{
    if (!str) return NULL;
    return g_string_chunk_insert_const(chunk, str);
}

static inline gboolean
cr_key_file_get_boolean_default(GKeyFile *key_file,
                                const gchar *group_name,
                                const gchar *key,
                                gboolean default_value,
                                GError **error)
{
    GError *tmp_err = NULL;
    gboolean ret = g_key_file_get_boolean(key_file, group_name, key, &tmp_err);
    if (tmp_err) {
        g_propagate_error(error, tmp_err);
        return default_value;
    }
    return ret;
}

int
cr_warning_cb(cr_XmlParserWarningType type,
           char *msg,
           void *cbdata,
           GError **err);

gboolean
cr_write_to_file(GError **err, gchar *filename, const char *format, ...);

typedef enum {
    CR_CP_DEFAULT       = (1<<0), 
    CR_CP_RECURSIVE     = (1<<1), 
    CR_CP_PRESERVE_ALL  = (1<<2), 
} cr_CpFlags;

gboolean
cr_cp(const char *src,
      const char *dst,
      cr_CpFlags flags,
      const char *working_directory,
      GError **err);

typedef enum {
    CR_RM_DEFAULT       = (1<<0), 
    CR_RM_RECURSIVE     = (1<<1), 
    CR_RM_FORCE         = (1<<2), 
} cr_RmFlags;

gboolean
cr_rm(const char *path,
      cr_RmFlags flags,
      const char *working_dir,
      GError **err);

gchar *
cr_append_pid_and_datetime(const char *str, const char *suffix);

gboolean
cr_spawn_check_exit_status(gint exit_status, GError **error);

cr_NEVR *
cr_str_to_nevr(const char *str);

void
cr_nevr_free(cr_NEVR *nevr);

cr_NEVRA *
cr_str_to_nevra(const char *str);

void
cr_nevra_free(cr_NEVRA *nevra);

gboolean
cr_identical_files(const gchar *fn1,
                   const gchar *fn2,
                   gboolean *identical,
                   GError **err);

gchar *
cr_cut_dirs(gchar *path, gint cut_dirs);

#ifdef __cplusplus
}
#endif

#endif /* __C_CREATEREPOLIB_MISC_H__ */