-gboolean check_arguments(struct CmdOptions *options)
+gboolean
+check_arguments(struct CmdOptions *options)
{
// Check outputdir
if (options->outputdir && !g_file_test(options->outputdir, G_FILE_TEST_EXISTS|G_FILE_TEST_IS_DIR)) {
-void free_options(struct CmdOptions *options)
+void
+free_options(struct CmdOptions *options)
{
g_free(options->input_dir);
g_free(options->location_base);
#define GZ_BUFFER_SIZE (1024*128)
#define BZ2_VERBOSITY 0
-#define BZ2_BLOCKSIZE100K 5 // Higher gives better compression but takes more memory
-#define BZ2_WORK_FACTOR 0 // 0 == default == 30 (available values 0-250)
+#define BZ2_BLOCKSIZE100K 5 // Higher gives better compression but takes
+ // more memory
+#define BZ2_WORK_FACTOR 0 // 0 == default == 30 (available 0-250)
#define BZ2_USE_LESS_MEMORY 0
#define BZ2_SKIP_FFLUSH 0
number 0..9
or
LZMA_PRESET_DEFAULT default preset
-LZMA_PRESET_EXTREME significantly slower, improving the compression ratio marginally
+LZMA_PRESET_EXTREME significantly slower, improving the compression ratio
+ marginally
*/
#define CR_CW_XZ_COMPRESSION_LEVEL 5
-cr_CompressionType cr_detect_compression(const char *filename)
+cr_CompressionType
+cr_detect_compression(const char *filename)
{
cr_CompressionType type = CR_CW_UNKNOWN_COMPRESSION;
if (!g_file_test(filename, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
- g_debug(MODULE"%s: File %s doesn't exists or it's not a regular file", __func__, filename);
+ g_debug(MODULE"%s: File %s doesn't exists or it's not a regular file",
+ __func__, filename);
return type;
}
const char *mime_type = magic_file(myt, filename);
if (mime_type) {
- g_debug(MODULE"%s: Detected mime type: %s (%s)", __func__, mime_type, filename);
+ g_debug(MODULE"%s: Detected mime type: %s (%s)", __func__, mime_type,
+ filename);
if (g_str_has_prefix(mime_type, "application/x-gzip") ||
g_str_has_prefix(mime_type, "application/gzip") ||
}
-const char *cr_get_suffix(cr_CompressionType comtype)
+const char *
+cr_compression_suffix(cr_CompressionType comtype)
{
char *suffix = NULL;
switch (comtype) {
}
-CR_FILE *cr_open(const char *filename, cr_OpenMode mode, cr_CompressionType comtype)
+CR_FILE *
+cr_open(const char *filename, cr_OpenMode mode, cr_CompressionType comtype)
{
CR_FILE *file = NULL;
cr_CompressionType type;
if (mode == CR_CW_MODE_WRITE) {
if (comtype == CR_CW_AUTO_DETECT_COMPRESSION) {
- g_debug(MODULE"%s: CR_CW_AUTO_DETECT_COMPRESSION cannot be used if mode is CR_CW_MODE_WRITE", __func__);
+ g_debug(MODULE"%s: CR_CW_AUTO_DETECT_COMPRESSION cannot be used if "
+ "mode is CR_CW_MODE_WRITE", __func__);
return NULL;
}
if (comtype == CR_CW_UNKNOWN_COMPRESSION) {
- g_debug(MODULE"%s: CR_CW_UNKNOWN_COMPRESSION cannot be used if mode is CR_CW_MODE_WRITE", __func__);
+ g_debug(MODULE"%s: CR_CW_UNKNOWN_COMPRESSION cannot be used if mode"
+ " is CR_CW_MODE_WRITE", __func__);
return NULL;
}
}
switch (type) {
- case (CR_CW_NO_COMPRESSION): // ----------------------------------------------
+ case (CR_CW_NO_COMPRESSION): // ----------------------------------------
file->type = CR_CW_NO_COMPRESSION;
if (mode == CR_CW_MODE_WRITE) {
file->FILE = (void *) fopen(filename, "w");
}
break;
- case (CR_CW_GZ_COMPRESSION): // ----------------------------------------------
+ case (CR_CW_GZ_COMPRESSION): // ----------------------------------------
file->type = CR_CW_GZ_COMPRESSION;
if (mode == CR_CW_MODE_WRITE) {
file->FILE = (void *) gzopen(filename, "wb");
- gzsetparams((gzFile) file->FILE, CR_CW_GZ_COMPRESSION_LEVEL, GZ_STRATEGY);
+ gzsetparams((gzFile) file->FILE,
+ CR_CW_GZ_COMPRESSION_LEVEL,
+ GZ_STRATEGY);
} else {
file->FILE = (void *) gzopen(filename, "rb");
}
}
break;
- case (CR_CW_BZ2_COMPRESSION): // ---------------------------------------------
+ case (CR_CW_BZ2_COMPRESSION): // ---------------------------------------
file->type = CR_CW_BZ2_COMPRESSION;
FILE *f;
if (mode == CR_CW_MODE_WRITE) {
f = fopen(filename, "wb");
if (f) {
- file->FILE = (void *) BZ2_bzWriteOpen(NULL, f, BZ2_BLOCKSIZE100K, BZ2_VERBOSITY, BZ2_WORK_FACTOR);
+ file->FILE = (void *) BZ2_bzWriteOpen(NULL, f,
+ BZ2_BLOCKSIZE100K,
+ BZ2_VERBOSITY,
+ BZ2_WORK_FACTOR);
}
} else {
f = fopen(filename, "rb");
if (f) {
- file->FILE = (void *) BZ2_bzReadOpen(NULL, f, BZ2_VERBOSITY, BZ2_USE_LESS_MEMORY, NULL, 0);
+ file->FILE = (void *) BZ2_bzReadOpen(NULL, f,
+ BZ2_VERBOSITY,
+ BZ2_USE_LESS_MEMORY,
+ NULL, 0);
}
}
break;
- case (CR_CW_XZ_COMPRESSION): // ----------------------------------------------
+ case (CR_CW_XZ_COMPRESSION): // ----------------------------------------
file->type = CR_CW_XZ_COMPRESSION;
XzFile *xz_file = g_malloc(sizeof(XzFile));
lzma_stream *stream = &(xz_file->stream);
memset(stream, 0, sizeof(lzma_stream));
/* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ XXX: This part
- is a little tricky. Because in the default initializer LZMA_STREAM_INIT
- are some items NULL and (according to C standard) NULL may have
- different internal representation than zero.
- This should not be a problem nowadays, but who knows what the future will bring.
+ is a little tricky. Because in the default initializer
+ LZMA_STREAM_INIT are some items NULL and (according to C standard)
+ NULL may have different internal representation than zero.
+ This should not be a problem nowadays.
*/
// Prepare coder/decoder
int ret;
if (mode == CR_CW_MODE_WRITE)
- ret = lzma_easy_encoder(stream, CR_CW_XZ_COMPRESSION_LEVEL, XZ_CHECK);
+ ret = lzma_easy_encoder(stream,
+ CR_CW_XZ_COMPRESSION_LEVEL,
+ XZ_CHECK);
else
- ret = lzma_auto_decoder(stream, XZ_MEMORY_USAGE_LIMIT, XZ_DECODER_FLAGS);
+ ret = lzma_auto_decoder(stream,
+ XZ_MEMORY_USAGE_LIMIT,
+ XZ_DECODER_FLAGS);
if (ret != LZMA_OK) {
switch (ret) {
case LZMA_MEM_ERROR:
- g_debug(MODULE"%s: XZ: Cannot allocate memory", __func__);
+ g_debug(MODULE"%s: XZ: Cannot allocate memory",
+ __func__);
break;
case LZMA_OPTIONS_ERROR:
- g_debug(MODULE"%s: XZ: Unsupported flags (options)", __func__);
+ g_debug(MODULE"%s: XZ: Unsupported flags (options)",
+ __func__);
break;
case LZMA_PROG_ERROR:
- g_debug(MODULE"%s: XZ: One or more of the parameters have values that will never be valid.", __func__);
+ g_debug(MODULE"%s: XZ: One or more of the parameters "
+ "have values that will never be valid.",
+ __func__);
break;
default:
g_debug(MODULE"%s: XZ: Unknown error", __func__);
-int cr_close(CR_FILE *cr_file)
+int
+cr_close(CR_FILE *cr_file)
{
if (!cr_file) {
return CR_CW_ERR;
switch (cr_file->type) {
- case (CR_CW_NO_COMPRESSION): // ----------------------------------------------
+ case (CR_CW_NO_COMPRESSION): // ----------------------------------------
ret = fclose((FILE *) cr_file->FILE);
if (ret == 0) {
cw_ret = CR_CW_OK;
}
break;
- case (CR_CW_GZ_COMPRESSION): // ----------------------------------------------
+ case (CR_CW_GZ_COMPRESSION): // ----------------------------------------
ret = gzclose((gzFile) cr_file->FILE);
if (ret == Z_OK) {
cw_ret = CR_CW_OK;
}
break;
- case (CR_CW_BZ2_COMPRESSION): // ---------------------------------------------
+ case (CR_CW_BZ2_COMPRESSION): // ---------------------------------------
if (cr_file->mode == CR_CW_MODE_READ) {
BZ2_bzReadClose(&ret, (BZFILE *) cr_file->FILE);
} else {
- BZ2_bzWriteClose(&ret, (BZFILE *) cr_file->FILE, BZ2_SKIP_FFLUSH, NULL, NULL);
+ BZ2_bzWriteClose(&ret, (BZFILE *) cr_file->FILE,
+ BZ2_SKIP_FFLUSH, NULL, NULL);
}
if (ret == BZ_OK) {
}
break;
- case (CR_CW_XZ_COMPRESSION): { // --------------------------------------------
+ case (CR_CW_XZ_COMPRESSION): { // --------------------------------------
XzFile *xz_file = (XzFile *) cr_file->FILE;
lzma_stream *stream = &(xz_file->stream);
-int cr_read(CR_FILE *cr_file, void *buffer, unsigned int len)
+int
+cr_read(CR_FILE *cr_file, void *buffer, unsigned int len)
{
if (!cr_file || !buffer || cr_file->mode != CR_CW_MODE_READ) {
return CR_CW_ERR;
switch (cr_file->type) {
- case (CR_CW_NO_COMPRESSION): // ----------------------------------------------
+ case (CR_CW_NO_COMPRESSION): // ----------------------------------------
ret = fread(buffer, 1, len, (FILE *) cr_file->FILE);
if ((ret != (int) len) && !feof((FILE *) cr_file->FILE)) {
ret = CR_CW_ERR;
}
break;
- case (CR_CW_GZ_COMPRESSION): // ----------------------------------------------
+ case (CR_CW_GZ_COMPRESSION): // ----------------------------------------
return gzread((gzFile) cr_file->FILE, buffer, len);
break;
- case (CR_CW_BZ2_COMPRESSION): // ---------------------------------------------
+ case (CR_CW_BZ2_COMPRESSION): // ---------------------------------------
ret = BZ2_bzRead(&bzerror, (BZFILE *) cr_file->FILE, buffer, len);
if (!ret && bzerror == BZ_SEQUENCE_ERROR)
// Next read after BZ_STREAM_END (EOF)
}
break;
- case (CR_CW_XZ_COMPRESSION): { // --------------------------------------------
+ case (CR_CW_XZ_COMPRESSION): { // --------------------------------------
XzFile *xz_file = (XzFile *) cr_file->FILE;
lzma_stream *stream = &(xz_file->stream);
-int cr_write(CR_FILE *cr_file, const void *buffer, unsigned int len)
+int
+cr_write(CR_FILE *cr_file, const void *buffer, unsigned int len)
{
if (!cr_file || !buffer || cr_file->mode != CR_CW_MODE_WRITE) {
return CR_CW_ERR;
switch (cr_file->type) {
- case (CR_CW_NO_COMPRESSION): // ----------------------------------------------
+ case (CR_CW_NO_COMPRESSION): // ----------------------------------------
if ((ret = (int) fwrite(buffer, 1, len, (FILE *) cr_file->FILE)) != (int) len) {
ret = CR_CW_ERR;
}
break;
- case (CR_CW_GZ_COMPRESSION): // ----------------------------------------------
+ case (CR_CW_GZ_COMPRESSION): // ----------------------------------------
if (len == 0) {
ret = 0;
break;
}
break;
- case (CR_CW_BZ2_COMPRESSION): // ---------------------------------------------
+ case (CR_CW_BZ2_COMPRESSION): // ---------------------------------------
BZ2_bzWrite(&bzerror, (BZFILE *) cr_file->FILE, (void *) buffer, len);
if (bzerror == BZ_OK) {
ret = len;
}
break;
- case (CR_CW_XZ_COMPRESSION): { // --------------------------------------------
+ case (CR_CW_XZ_COMPRESSION): { // --------------------------------------
XzFile *xz_file = (XzFile *) cr_file->FILE;
lzma_stream *stream = &(xz_file->stream);
-int cr_puts(CR_FILE *cr_file, const char *str)
+int
+cr_puts(CR_FILE *cr_file, const char *str)
{
if (!cr_file || !str || cr_file->mode != CR_CW_MODE_WRITE) {
return CR_CW_ERR;
switch (cr_file->type) {
- case (CR_CW_NO_COMPRESSION): // ----------------------------------------------
+ case (CR_CW_NO_COMPRESSION): // ----------------------------------------
if (fputs(str, (FILE *) cr_file->FILE) != EOF) {
ret = CR_CW_OK;
}
break;
- case (CR_CW_GZ_COMPRESSION): // ----------------------------------------------
+ case (CR_CW_GZ_COMPRESSION): // ----------------------------------------
if (gzputs((gzFile) cr_file->FILE, str) != -1) {
ret = CR_CW_OK;
}
break;
- case (CR_CW_BZ2_COMPRESSION): // ---------------------------------------------
+ case (CR_CW_BZ2_COMPRESSION): // ---------------------------------------
len = strlen(str);
BZ2_bzWrite(&bzerror, (BZFILE *) cr_file->FILE, (void *) str, len);
if (bzerror == BZ_OK) {
}
break;
- case (CR_CW_XZ_COMPRESSION): // ----------------------------------------------
+ case (CR_CW_XZ_COMPRESSION): // ----------------------------------------
len = strlen(str);
ret = cr_write(cr_file, str, len);
if (ret == (int) len) {
-int cr_printf(CR_FILE *cr_file, const char *format, ...)
+int
+cr_printf(CR_FILE *cr_file, const char *format, ...)
{
if (!cr_file || !format || cr_file->mode != CR_CW_MODE_WRITE) {
return CR_CW_ERR;
switch (cr_file->type) {
- case (CR_CW_NO_COMPRESSION): // ----------------------------------------------
+ case (CR_CW_NO_COMPRESSION): // ----------------------------------------
if ((ret = fwrite(buf, 1, ret, cr_file->FILE)) < 0) {
ret = CR_CW_ERR;
}
break;
- case (CR_CW_GZ_COMPRESSION): // ----------------------------------------------
+ case (CR_CW_GZ_COMPRESSION): // ----------------------------------------
if (gzputs((gzFile) cr_file->FILE, buf) == -1) {
ret = CR_CW_ERR;
}
break;
- case (CR_CW_BZ2_COMPRESSION): // ---------------------------------------------
+ case (CR_CW_BZ2_COMPRESSION): // ---------------------------------------
BZ2_bzWrite(&tmp_ret, (BZFILE *) cr_file->FILE, buf, ret);
if (tmp_ret != BZ_OK) {
ret = CR_CW_ERR;
}
break;
- case (CR_CW_XZ_COMPRESSION): // ----------------------------------------------
+ case (CR_CW_XZ_COMPRESSION): // ----------------------------------------
tmp_ret = cr_write(cr_file, buf, ret);
if (tmp_ret != (int) ret) {
ret = CR_CW_ERR;
* @param comtype compression type
* @return common file suffix
*/
-const char *cr_get_suffix(cr_CompressionType comtype);
+const char *cr_compression_suffix(cr_CompressionType comtype);
/** \ingroup compression_wrapper
* Detect a compression type of the specified file.
* @param comtype type of compression
* @return pointer to a CR_FILE or NULL
*/
-CR_FILE *cr_open(const char *filename, cr_OpenMode mode, cr_CompressionType comtype);
+CR_FILE *cr_open(const char *filename,
+ cr_OpenMode mode,
+ cr_CompressionType comtype);
/** \ingroup compression_wrapper
* Reads an array of len bytes from the CR_FILE.
* @param CR_FILE CR_FILE pointer
* @param buffer source buffer
* @param len number of bytes to read
- * @return number of uncompressed bytes readed (0 = EOF) or CR_CW_ERR
+ * @return number of uncompressed bytes readed (0 = EOF)
+ * or CR_CW_ERR
*/
int cr_write(CR_FILE *cr_file, const void *buffer, unsigned int len);
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
+#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
// Signal handler
-void sigint_catcher(int sig)
+void
+sigint_catcher(int sig)
{
CR_UNUSED(sig);
g_message("SIGINT catched: Terminating...");
-int allowed_file(const gchar *filename, struct CmdOptions *options)
+int
+allowed_file(const gchar *filename, struct CmdOptions *options)
{
// Check file against exclude glob masks
if (options->exclude_masks) {
G_LOCK_DEFINE (LOCK_OTH);
-void dumper_thread(gpointer data, gpointer user_data) {
+void
+dumper_thread(gpointer data, gpointer user_data)
+{
struct UserData *udata = (struct UserData *) user_data;
struct PoolTask *task = (struct PoolTask *) data;
- // get location_href without leading part of path (path to repo) including '/' char
+ // get location_href without leading part of path (path to repo)
+ // including '/' char
const char *location_href = task->full_path + udata->repodir_name_len;
const char *location_base = udata->location_base;
}
if (old_used) {
- // We have usable old data, but we have to set locations (href and base)
+ // We have usable old data, but we have to set proper locations
md->location_href = (char *) location_href;
md->location_base = (char *) location_base;
}
-int main(int argc, char **argv) {
-
-
+int
+main(int argc, char **argv)
+{
// Arguments parsing
struct CmdOptions *cmd_options;
if (g_mkdir (tmp_out_repo, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)) {
if (errno == EEXIST) {
- g_critical("Temporary repodata directory: %s already exists! (Another createrepo process is running?)", tmp_out_repo);
+ g_critical("Temporary repodata directory: %s already exists! ("
+ "Another createrepo process is running?)", tmp_out_repo);
} else {
- g_critical("Error while creating temporary repodata directory %s: %s", tmp_out_repo, strerror(errno));
+ g_critical("Error while creating temporary repodata directory %s: %s",
+ tmp_out_repo, strerror(errno));
}
exit(1);
groupfile_compression = CR_CW_XZ_COMPRESSION;
}
- sqlite_compression_suffix = cr_get_suffix(sqlite_compression);
+ sqlite_compression_suffix = cr_compression_suffix(sqlite_compression);
// Create and open new compressed files
user_data.oth_statements = oth_statements;
user_data.changelog_limit = cmd_options->changelog_limit;
user_data.location_base = cmd_options->location_base;
- user_data.checksum_type_str = cr_get_checksum_name_str(cmd_options->checksum_type);
+ user_data.checksum_type_str = cr_checksum_name_str(cmd_options->checksum_type);
user_data.checksum_type = cmd_options->checksum_type;
user_data.quiet = cmd_options->quiet;
user_data.verbose = cmd_options->verbose;
// Thread pool - Creation
g_thread_init(NULL);
- GThreadPool *pool = g_thread_pool_new(dumper_thread, &user_data, 0, TRUE, NULL);
+ GThreadPool *pool = g_thread_pool_new(dumper_thread,
+ &user_data,
+ 0,
+ TRUE,
+ NULL);
g_debug("Thread pool ready");
size_t in_dir_len = strlen(in_dir);
GStringChunk *sub_dirs_chunk = g_string_chunk_new(1024);
GQueue *sub_dirs = g_queue_new();
- gchar *input_dir_stripped = g_string_chunk_insert_len(sub_dirs_chunk, in_dir, in_dir_len-1);
+ gchar *input_dir_stripped;
+
+ input_dir_stripped = g_string_chunk_insert_len(sub_dirs_chunk,
+ in_dir,
+ in_dir_len-1);
g_queue_push_head(sub_dirs, input_dir_stripped);
char *dirname;
g_file_test(full_path, G_FILE_TEST_IS_DIR))
{
// Directory
- gchar *sub_dir_in_chunk = g_string_chunk_insert (sub_dirs_chunk, full_path);
+ gchar *sub_dir_in_chunk;
+ sub_dir_in_chunk = g_string_chunk_insert(sub_dirs_chunk,
+ full_path);
g_queue_push_head(sub_dirs, sub_dir_in_chunk);
g_debug("Dir to scan: %s", sub_dir_in_chunk);
}
struct PoolTask *task = g_malloc(sizeof(struct PoolTask));
task->full_path = full_path;
task->filename = g_strdup(filename);
- task->path = g_strdup(dirname); // TODO: One common path for all tasks with the same path??
+ task->path = g_strdup(dirname);
+ // TODO: One common path for all tasks with the same path?
g_thread_pool_push(pool, task, NULL);
package_count++;
}
GSList *element;
for (element=cmd_options->include_pkgs; element; element=g_slist_next(element)) {
- gchar *relative_path = (gchar *) element->data; // path from pkglist e.g. packages/i386/foobar.rpm
- gchar *full_path = g_strconcat(in_dir, relative_path, NULL); // /path/to/in_repo/packages/i386/foobar.rpm
- gchar *dirname; // packages/i386/
+ gchar *relative_path = (gchar *) element->data;
+ // ^^^ path from pkglist e.g. packages/i386/foobar.rpm
+ gchar *full_path = g_strconcat(in_dir, relative_path, NULL);
+ // ^^^ /path/to/in_repo/packages/i386/foobar.rpm
+ gchar *dirname; // packages/i386/
gchar *filename; // foobar.rpm
// Get index of last '/'
g_debug("Writing xml headers");
cr_printf(user_data.pri_f, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
- "<metadata xmlns=\""CR_XML_COMMON_NS"\" xmlns:rpm=\""CR_XML_RPM_NS"\" packages=\"%d\">\n", package_count);
+ "<metadata xmlns=\""CR_XML_COMMON_NS"\" xmlns:rpm=\""
+ CR_XML_RPM_NS"\" packages=\"%d\">\n", package_count);
cr_printf(user_data.fil_f, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
- "<filelists xmlns=\""CR_XML_FILELISTS_NS"\" packages=\"%d\">\n", package_count);
+ "<filelists xmlns=\""CR_XML_FILELISTS_NS"\" packages=\"%d\">\n",
+ package_count);
cr_printf(user_data.oth_f, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
- "<otherdata xmlns=\""CR_XML_OTHER_NS"\" packages=\"%d\">\n", package_count);
+ "<otherdata xmlns=\""CR_XML_OTHER_NS"\" packages=\"%d\">\n",
+ package_count);
// Start pool
// Groupfile
if (groupfile) {
- gchar *groupfile_name = g_strconcat("repodata/", cr_get_filename(groupfile), NULL);
+ gchar *groupfile_name = g_strconcat("repodata/",
+ cr_get_filename(groupfile),
+ NULL);
groupfile_rec = cr_new_repomdrecord(groupfile_name);
compressed_groupfile_rec = cr_new_repomdrecord(groupfile_name);
// Sqlite db
if (!cmd_options->no_database) {
- gchar *pri_db_name = g_strconcat("repodata/primary.sqlite", sqlite_compression_suffix, NULL);
- gchar *fil_db_name = g_strconcat("repodata/filelists.sqlite", sqlite_compression_suffix, NULL);
- gchar *oth_db_name = g_strconcat("repodata/other.sqlite", sqlite_compression_suffix, NULL);
+ gchar *pri_db_name = g_strconcat("repodata/primary.sqlite",
+ sqlite_compression_suffix, NULL);
+ gchar *fil_db_name = g_strconcat("repodata/filelists.sqlite",
+ sqlite_compression_suffix, NULL);
+ gchar *oth_db_name = g_strconcat("repodata/other.sqlite",
+ sqlite_compression_suffix, NULL);
gchar *tmp_pri_db_path;
gchar *tmp_fil_db_path;
-void free_values(gpointer data)
+void
+free_values(gpointer data)
{
cr_package_free((cr_Package *) data);
}
-GHashTable *cr_new_metadata_hashtable()
+GHashTable *
+cr_new_metadata_hashtable()
{
GHashTable *hashtable = g_hash_table_new_full(g_str_hash, g_str_equal,
NULL, free_values);
-void cr_destroy_metadata_hashtable(GHashTable *hashtable)
+void
+cr_destroy_metadata_hashtable(GHashTable *hashtable)
{
if (hashtable) {
g_hash_table_destroy (hashtable);
inline gchar *
-chunk_insert_len_or_null (GStringChunk *chunk, const gchar *str, gssize len) {
+chunk_insert_len_or_null (GStringChunk *chunk, const gchar *str, gssize len)
+{
if (!str || len <= 0)
return NULL;
// primary.xml parser handlers
-void pri_start_handler(void *data, const char *el, const char **attr) {
+void
+pri_start_handler(void *data, const char *el, const char **attr)
+{
struct ParserData *ppd = (struct ParserData *) data;
cr_Package *pkg = ppd->pkg;
int i;
-void pri_char_handler(void *data, const char *txt, int txtlen) {
+void
+pri_char_handler(void *data, const char *txt, int txtlen)
+{
struct ParserData *ppd = (struct ParserData *) data;
cr_Package *pkg = ppd->pkg;
-void pri_end_handler(void *data, const char *el) {
+void
+pri_end_handler(void *data, const char *el)
+{
struct ParserData *ppd = (struct ParserData *) data;
cr_Package *pkg = ppd->pkg;
// filelists.xml parser handlers
-void fil_start_handler(void *data, const char *el, const char **attr) {
+void
+fil_start_handler(void *data, const char *el, const char **attr)
+{
int i;
struct ParserData *ppd = (struct ParserData *) data;
cr_Package *pkg = ppd->pkg;
}
if (key) {
- ppd->pkg = (cr_Package *) g_hash_table_lookup(ppd->hashtable, (gconstpointer) key);
+ ppd->pkg = (cr_Package *) g_hash_table_lookup(ppd->hashtable,
+ (gconstpointer) key);
if (!ppd->pkg) {
ppd->error = TRUE;
g_critical(MODULE"%s: Unknown package (package ID: %s)",
-void fil_char_handler(void *data, const char *txt, int txtlen) {
+void
+fil_char_handler(void *data, const char *txt, int txtlen)
+{
struct ParserData *ppd = (struct ParserData *) data;
cr_Package *pkg = ppd->pkg;
-void fil_end_handler(void *data, const char *el) {
+void
+fil_end_handler(void *data, const char *el)
+{
struct ParserData *ppd = (struct ParserData *) data;
cr_Package *pkg = ppd->pkg;
// other.xml parser handlers
-void oth_start_handler(void *data, const char *el, const char **attr) {
+void
+oth_start_handler(void *data, const char *el, const char **attr)
+{
int i;
struct ParserData *ppd = (struct ParserData *) data;
cr_Package *pkg = ppd->pkg;
-void oth_char_handler(void *data, const char *txt, int txtlen) {
+void
+oth_char_handler(void *data, const char *txt, int txtlen)
+{
struct ParserData *ppd = (struct ParserData *) data;
cr_Package *pkg = ppd->pkg;
-void oth_end_handler(void *data, const char *el) {
+void
+oth_end_handler(void *data, const char *el)
+{
struct ParserData *ppd = (struct ParserData *) data;
cr_Package *pkg = ppd->pkg;
-int load_xml_files(GHashTable *hashtable, const char *primary_xml_path,
- const char *filelists_xml_path, const char *other_xml_path)
+int
+load_xml_files(GHashTable *hashtable, const char *primary_xml_path,
+ const char *filelists_xml_path, const char *other_xml_path)
{
cr_CompressionType compression_type;
CR_FILE *pri_xml_cwfile, *fil_xml_cwfile, *oth_xml_cwfile;
* @param hashtable destination metadata hashtable
* @param ml metadata location
* @param key hashtable key
- * @return return code (CR_LOAD_METADATA_OK or CR_LOAD_METADATA_ERR)
+ * @return return code CR_LOAD_METADATA_OK or CR_LOAD_METADATA_ERR
*/
int cr_load_xml_metadata(GHashTable *hashtable,
struct cr_MetadataLocation *ml,
* @param hashtable destination metadata hashtable
* @param repopath path to repo (to directory with repodata/ subdir)
* @param key hashtable key
- * @return return code (CR_LOAD_METADATA_OK or CR_LOAD_METADATA_ERR)
+ * @return return code CR_LOAD_METADATA_OK or CR_LOAD_METADATA_ERR
*/
int cr_locate_and_load_xml_metadata(GHashTable *hashtable,
const char *repopath,
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
+ * USA
*/
#include <glib.h>
ret = xmlTextReaderRead(reader);
name = xmlTextReaderName(reader);
if (g_strcmp0((char *) name, "repomd")) {
- g_warning(MODULE"%s: Bad xml - missing repomd element? (%s)", __func__, name);
+ g_warning(MODULE"%s: Bad xml - missing repomd element? (%s)",
+ __func__, name);
xmlFree(name);
xmlFreeTextReader(reader);
return NULL;
ret = xmlTextReaderRead(reader);
name = xmlTextReaderName(reader);
if (g_strcmp0((char *) name, "revision")) {
- g_warning(MODULE"%s: Bad xml - missing revision element? (%s)", __func__, name);
+ g_warning(MODULE"%s: Bad xml - missing revision element? (%s)",
+ __func__, name);
xmlFree(name);
xmlFreeTextReader(reader);
return NULL;
mdloc->oth_sqlite_href = full_location_href;
} else if (!g_strcmp0((char *) data_type, "group")) {
mdloc->groupfile_href = full_location_href;
- } else if (!g_strcmp0((char *) data_type, "group_gz")) { // even with a createrepo param --xz this name has a _gz suffix
+ } else if (!g_strcmp0((char *) data_type, "group_gz")) {
+ // even with a createrepo param --xz this name has a _gz suffix
mdloc->cgroupfile_href = full_location_href;
}
// Create temporary repo in /tmp
if(!mkdtemp(tmp_dir)) {
- g_critical(MODULE"%s: Cannot create a temporary directory: %s", __func__, strerror(errno));
+ g_critical(MODULE"%s: Cannot create a temporary directory: %s",
+ __func__, strerror(errno));
return ret;
}
// Return list of non-null pointers on strings in the passed structure
-GSList *get_list_of_md_locations (struct cr_MetadataLocation *ml)
+GSList *
+get_list_of_md_locations (struct cr_MetadataLocation *ml)
{
GSList *list = NULL;
-void free_list_of_md_locations(GSList *list)
+void
+free_list_of_md_locations(GSList *list)
{
if (list) {
g_slist_free(list);
-int cr_remove_metadata(const char *repopath)
+int
+cr_remove_metadata(const char *repopath)
{
if (!repopath || !g_file_test(repopath, G_FILE_TEST_EXISTS|G_FILE_TEST_IS_DIR)) {
g_debug(MODULE"%s: remove_old_metadata: Cannot remove %s", __func__, repopath);
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
+ * USA
*/
#include <glib.h>
+#include <stdio.h>
+#include <stdlib.h>
#include <assert.h>
#include <sys/stat.h>
#include <errno.h>
static GOptionEntry cmd_entries[] =
{
- { "version", 0, 0, G_OPTION_ARG_NONE, &(_cmd_options.version), "Show program's version number and exit", NULL },
- { "repo", 'r', 0, G_OPTION_ARG_FILENAME_ARRAY, &(_cmd_options.repos), "Repo url", "REPOS" },
- { "archlist", 'a', 0, G_OPTION_ARG_STRING, &(_cmd_options.archlist), "Defaults to all arches - otherwise specify arches", "ARCHLIST" },
- { "database", 'd', 0, G_OPTION_ARG_NONE, &(_cmd_options.database), "", NULL },
- { "no-database", 0, 0, G_OPTION_ARG_NONE, &(_cmd_options.no_database), "", NULL },
- { "verbose", 'v', 0, G_OPTION_ARG_NONE, &(_cmd_options.verbose), "", NULL },
- { "outputdir", 'o', 0, G_OPTION_ARG_FILENAME, &(_cmd_options.outputdir), "Location to create the repository", "OUTPUTDIR" },
- { "nogroups", 0, 0, G_OPTION_ARG_NONE, &(_cmd_options.nogroups), "Do not merge group (comps) metadata", NULL },
- { "noupdateinfo", 0, 0, G_OPTION_ARG_NONE, &(_cmd_options.noupdateinfo), "Do not merge updateinfo metadata", NULL },
- { "compress-type", 0, 0, G_OPTION_ARG_STRING, &(_cmd_options.compress_type), "Which compression type to use", "COMPRESS_TYPE" },
- { "method", 0, 0, G_OPTION_ARG_STRING, &(_cmd_options.merge_method_str), "Specify merge method for packages with the same name and arch (available merge methods: repo (default), ts, nvr)", "MERGE_METHOD" },
- { "all", 0, 0, G_OPTION_ARG_NONE, &(_cmd_options.all), "Include all packages with the same name and arch if version or release is different. If used --method argument is ignored!", NULL },
- { "noarch-repo", 0, 0, G_OPTION_ARG_FILENAME, &(_cmd_options.noarch_repo_url), "Packages with noarch architecture will be replaced by package from this repo if exists in it.", "URL" },
+ { "version", 0, 0, G_OPTION_ARG_NONE, &(_cmd_options.version),
+ "Show program's version number and exit", NULL },
+ { "repo", 'r', 0, G_OPTION_ARG_FILENAME_ARRAY, &(_cmd_options.repos),
+ "Repo url", "REPOS" },
+ { "archlist", 'a', 0, G_OPTION_ARG_STRING, &(_cmd_options.archlist),
+ "Defaults to all arches - otherwise specify arches", "ARCHLIST" },
+ { "database", 'd', 0, G_OPTION_ARG_NONE, &(_cmd_options.database),
+ "", NULL },
+ { "no-database", 0, 0, G_OPTION_ARG_NONE, &(_cmd_options.no_database),
+ "", NULL },
+ { "verbose", 'v', 0, G_OPTION_ARG_NONE, &(_cmd_options.verbose),
+ "", NULL },
+ { "outputdir", 'o', 0, G_OPTION_ARG_FILENAME, &(_cmd_options.outputdir),
+ "Location to create the repository", "OUTPUTDIR" },
+ { "nogroups", 0, 0, G_OPTION_ARG_NONE, &(_cmd_options.nogroups),
+ "Do not merge group (comps) metadata", NULL },
+ { "noupdateinfo", 0, 0, G_OPTION_ARG_NONE, &(_cmd_options.noupdateinfo),
+ "Do not merge updateinfo metadata", NULL },
+ { "compress-type", 0, 0, G_OPTION_ARG_STRING, &(_cmd_options.compress_type),
+ "Which compression type to use", "COMPRESS_TYPE" },
+ { "method", 0, 0, G_OPTION_ARG_STRING, &(_cmd_options.merge_method_str),
+ "Specify merge method for packages with the same name and arch (available"
+ " merge methods: repo (default), ts, nvr)", "MERGE_METHOD" },
+ { "all", 0, 0, G_OPTION_ARG_NONE, &(_cmd_options.all),
+ "Include all packages with the same name and arch if version or release "
+ "is different. If used --method argument is ignored!", NULL },
+ { "noarch-repo", 0, 0, G_OPTION_ARG_FILENAME, &(_cmd_options.noarch_repo_url),
+ "Packages with noarch architecture will be replaced by package from this "
+ "repo if exists in it.", "URL" },
{ NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL }
};
while (arch_set && arch_set[x] != NULL) {
gchar *arch = arch_set[x];
if (arch[0] != '\0') {
- options->arch_list = g_slist_prepend(options->arch_list, (gpointer) g_strdup(arch));
+ options->arch_list = g_slist_prepend(options->arch_list,
+ (gpointer) g_strdup(arch));
}
x++;
}
options->db_compression_type = CR_CW_XZ_COMPRESSION;
options->groupfile_compression_type = CR_CW_XZ_COMPRESSION;
} else {
- g_critical("Compression %s not available: Please choose from: gz or bz2 or xz", options->compress_type);
+ g_critical("Compression %s not available: Please choose from: "
+ "gz or bz2 or xz", options->compress_type);
ret = FALSE;
}
}
GError *error = NULL;
GOptionContext *context;
- context = g_option_context_new(": take 2 or more repositories and merge their metadata into a new repo");
+ context = g_option_context_new(": take 2 or more repositories and merge "
+ "their metadata into a new repo");
g_option_context_add_main_entries(context, cmd_entries, NULL);
gboolean ret = g_option_context_parse(context, argc, argv, &error);
GHashTable *
new_merged_metadata_hashtable()
{
- GHashTable *hashtable = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, free_merged_values); // TODO!!
+ GHashTable *hashtable = g_hash_table_new_full(g_str_hash,
+ g_str_equal,
+ NULL,
+ free_merged_values); // TODO!!
return hashtable;
}
// 1 = Package was added
// 2 = Package replaced old package
int
-add_package(cr_Package *pkg, gchar *repopath, GHashTable *merged, GSList *arch_list,
- MergeMethod merge_method, gboolean include_all)
+add_package(cr_Package *pkg,
+ gchar *repopath,
+ GHashTable *merged,
+ GSList *arch_list,
+ MergeMethod merge_method,
+ gboolean include_all)
{
GSList *list, *element;
if (!include_all) {
// Two packages has same name and arch
- // Use selected merge method to determine which package should be included
+ // Use selected merge method to determine which package should
+ // be included
// REPO merge method
if (merge_method == MM_REPO) {
// Package with the same arch already exists
- g_debug("Package %s (%s) already exists", pkg->name, pkg->arch);
+ g_debug("Package %s (%s) already exists",
+ pkg->name, pkg->arch);
return 0;
// TS merge method
cr_package_free(c_pkg);
// Replace package in element
if (!pkg->location_base)
- pkg->location_base = g_string_chunk_insert(pkg->chunk, repopath);
+ pkg->location_base = g_string_chunk_insert(pkg->chunk,
+ repopath);
element->data = pkg;
return 2;
} else {
- g_debug("Newer package %s (%s) already exists", pkg->name, pkg->arch);
+ g_debug("Newer package %s (%s) already exists",
+ pkg->name, pkg->arch);
return 0;
}
element->data = pkg;
return 2;
} else {
- g_debug("Newer version of package %s (%s) already exists", pkg->name, pkg->arch);
+ g_debug("Newer version of package %s (%s) already exists",
+ pkg->name, pkg->arch);
return 0;
}
}
long c_pkg_release = (c_pkg->release) ? strtol(c_pkg->release, NULL, 10) : 0;
if (cmp_res == 0 && pkg_release == c_pkg_release) {
- // Package with same name, arch, version and release is already listed
- g_debug("Same version of package %s (%s) already exists", pkg->name, pkg->arch);
+ // Package with same name, arch, version and release
+ // is already listed
+ g_debug("Same version of package %s (%s) already exists",
+ pkg->name, pkg->arch);
return 0;
}
}
}
// XXX: The first list element (pointed from hashtable) must stay first!
- // g_slist_append() is suitable but non effective, insert a new element right after
- // first element is optimal (at least for now)
+ // g_slist_append() is suitable but non effective, insert a new element
+ // right after first element is optimal (at least for now)
assert(g_slist_insert(list, pkg, 1) == list);
return 1;
long
-merge_repos(GHashTable *merged, GSList *repo_list, GSList *arch_list, MergeMethod merge_method,
- gboolean include_all, GHashTable *noarch_hashtable) {
+merge_repos(GHashTable *merged,
+ GSList *repo_list,
+ GSList *arch_list,
+ MergeMethod merge_method,
+ gboolean include_all,
+ GHashTable *noarch_hashtable)
+{
long loaded_packages = 0;
GSList *used_noarch_keys = NULL;
} else {
// Package from noarch repo was added - do not remove record, just make note
used_noarch_keys = g_slist_prepend(used_noarch_keys, pkg->location_href);
- g_debug("Package: %s (from: %s) has been replaced by noarch package", pkg->location_href, repopath);
+ g_debug("Package: %s (from: %s) has been replaced by noarch package",
+ pkg->location_href, repopath);
}
if (ret == 1) {
loaded_packages += repo_loaded_packages;
cr_destroy_metadata_hashtable(tmp_hashtable);
- g_debug("Repo: %s (Loaded: %ld Used: %ld)", repopath, (unsigned long) original_size, repo_loaded_packages);
+ g_debug("Repo: %s (Loaded: %ld Used: %ld)", repopath,
+ (unsigned long) original_size, repo_loaded_packages);
g_free(repopath);
}
int
-dump_merged_metadata(GHashTable *merged_hashtable, long packages,
- gchar *groupfile, struct CmdOptions *cmd_options)
+dump_merged_metadata(GHashTable *merged_hashtable,
+ long packages,
+ gchar *groupfile,
+ struct CmdOptions *cmd_options)
{
// Create/Open output xml files
CR_FILE *fil_f;
CR_FILE *oth_f;
- const char *db_suffix = cr_get_suffix(cmd_options->db_compression_type);
- const char *groupfile_suffix = cr_get_suffix(cmd_options->groupfile_compression_type);
+ const char *db_suffix = cr_compression_suffix(cmd_options->db_compression_type);
+ const char *groupfile_suffix = cr_compression_suffix(cmd_options->groupfile_compression_type);
gchar *pri_xml_filename = g_strconcat(cmd_options->out_repo, "/primary.xml.gz", NULL);
gchar *fil_xml_filename = g_strconcat(cmd_options->out_repo, "/filelists.xml.gz", NULL);
// Write xml headers
cr_printf(pri_f, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
- "<metadata xmlns=\""CR_XML_COMMON_NS"\" xmlns:rpm=\""CR_XML_RPM_NS"\" packages=\"%d\">\n", packages);
+ "<metadata xmlns=\""CR_XML_COMMON_NS"\" xmlns:rpm=\""
+ CR_XML_RPM_NS"\" packages=\"%d\">\n", packages);
cr_printf(fil_f, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
- "<filelists xmlns=\""CR_XML_FILELISTS_NS"\" packages=\"%d\">\n", packages);
+ "<filelists xmlns=\""CR_XML_FILELISTS_NS"\" packages=\"%d\">\n",
+ packages);
cr_printf(oth_f, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
- "<otherdata xmlns=\""CR_XML_OTHER_NS"\" packages=\"%d\">\n", packages);
+ "<otherdata xmlns=\""CR_XML_OTHER_NS"\" packages=\"%d\">\n",
+ packages);
// Prepare sqlite if needed
// Groupfile
if (groupfile) {
- gchar *groupfile_name = g_strconcat("repodata/", cr_get_filename(groupfile), NULL);
+ gchar *groupfile_name = g_strconcat("repodata/",
+ cr_get_filename(groupfile), NULL);
groupfile_rec = cr_new_repomdrecord(groupfile_name);
compressed_groupfile_rec = cr_new_repomdrecord(groupfile_name);
// Update info
if (!cmd_options->noupdateinfo) {
- gchar *update_info_name = g_strconcat("repodata/updateinfo.xml", groupfile_suffix, NULL);
+ gchar *update_info_name = g_strconcat("repodata/updateinfo.xml",
+ groupfile_suffix, NULL);
update_info_rec = cr_new_repomdrecord(update_info_name);
cr_fill_missing_data(out_dir, update_info_rec, NULL);
g_free(update_info_name);
if (g_slist_length(cmd_options->repo_list) < 2) {
free_options(cmd_options);
fprintf(stderr, "Usage: %s [options]\n\n"
- "%s: take 2 or more repositories and merge their metadata into a new repo\n\n",
+ "%s: take 2 or more repositories and merge their "
+ "metadata into a new repo\n\n",
cr_get_filename(argv[0]), cr_get_filename(argv[0]));
return 1;
}
const char *
-cr_get_checksum_name_str(cr_ChecksumType type)
+cr_checksum_name_str(cr_ChecksumType type)
{
char *name = NULL;
int
-cr_compress_file(const char *src, const char *in_dst, cr_CompressionType compression)
+cr_compress_file(const char *src,
+ const char *in_dst,
+ cr_CompressionType compression)
{
int readed;
char buf[BUFFER_SIZE];
gchar *dst = (gchar *) in_dst;
if (!dst) {
// If destination is NULL, use src + compression suffix
- const gchar *suffix = cr_get_suffix(compression);
+ const gchar *suffix = cr_compression_suffix(compression);
dst = g_strconcat(src, suffix, NULL);
} else {
// If destination is dir use filename from src + compression suffix
if (g_str_has_suffix(in_dst, "/")) {
- const gchar *suffix = cr_get_suffix(compression);
+ const gchar *suffix = cr_compression_suffix(compression);
dst = g_strconcat(in_dst, cr_get_filename(src), suffix, NULL);
}
}
int
-cr_remove_dir_cb(const char *fpath, const struct stat *sb, int typeflag,
- struct FTW *ftwbuf)
+cr_remove_dir_cb(const char *fpath,
+ const struct stat *sb,
+ int typeflag,
+ struct FTW *ftwbuf)
{
CR_UNUSED(sb);
CR_UNUSED(typeflag);
void
-cr_black_hole_log_function(const gchar *log_domain, GLogLevelFlags log_level,
- const gchar *message, gpointer user_data)
+cr_black_hole_log_function(const gchar *log_domain,
+ GLogLevelFlags log_level,
+ const gchar *message,
+ gpointer user_data)
{
CR_UNUSED(log_domain);
CR_UNUSED(log_level);
void
-cr_log_function (const gchar *log_domain, GLogLevelFlags log_level,
- const gchar *message, gpointer user_data)
+cr_log_function(const gchar *log_domain,
+ GLogLevelFlags log_level,
+ const gchar *message,
+ gpointer user_data)
{
CR_UNUSED(user_data);
#endif
#include <glib.h>
+#include <string.h>
#include <curl/curl.h>
#include "compression_wrapper.h"
#include "constants.h"
/** \ingroup misc
* Macro for supress compiler warning about unused param.
*/
-#define CR_UNUSED(x) (void)(x) /* Suppress compiler warning about unused param */
+#define CR_UNUSED(x) (void)(x)
/** \ingroup misc
* Convert flags from RPM header to a string representation.
* @return constant null terminated string with checksum name
* or NULL on error
*/
-const char *cr_get_checksum_name_str(cr_ChecksumType type);
+const char *cr_checksum_name_str(cr_ChecksumType type);
/** \ingroup misc
- * Return pointer to rest of string after last '/'.
+ * Return pointer to the rest of string after last '/'.
* (e.g. for "/foo/bar" returns "bar")
* @param filepath path
* @return pointer into the path
* @param error pointer to string pointer for error message
* (mandatory argument!)
*/
-void cr_download(CURL *handle, const char *url, const char *destination,
+void cr_download(CURL *handle,
+ const char *url,
+ const char *destination,
char **error);
/** \ingroup misc
* @param message message
* @param user_data user data
*/
-void cr_log_function(const gchar *log_domain, GLogLevelFlags log_level,
- const gchar *message, gpointer user_data);
+void cr_log_function(const gchar *log_domain,
+ GLogLevelFlags log_level,
+ const gchar *message,
+ gpointer user_data);
#ifdef __cplusplus
}
/* createrepo_c - Library of routines for manipulation with repodata
* Copyright (C) 2012 Tomas Mlcoch
+ * Copyright (C) 2006 Seth Vidal
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
#define PACKAGE_CHUNK_SIZE 2048
cr_Dependency *
-cr_dependency_new (void)
+cr_dependency_new(void)
{
cr_Dependency *dep;
}
cr_PackageFile *
-cr_package_file_new (void)
+cr_package_file_new(void)
{
cr_PackageFile *file;
}
cr_ChangelogEntry *
-cr_changelog_entry_new (void)
+cr_changelog_entry_new(void)
{
cr_ChangelogEntry *entry;
}
cr_Package *
-cr_package_new (void)
+cr_package_new(void)
{
cr_Package *package;
}
void
-cr_package_free (cr_Package *package)
+cr_package_free(cr_Package *package)
{
g_string_chunk_free (package->chunk);
/* createrepo_c - Library of routines for manipulation with repodata
* Copyright (C) 2012 Tomas Mlcoch
+ * Copyright (C) 2007 James Bowes
+ * Copyright (C) 2006 Seth Vidal
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
+ * USA
*/
#include <glib.h>
#define MODULE "parsehdr: "
-inline gchar *safe_string_chunk_insert(GStringChunk *chunk, const char *str)
+inline gchar *
+safe_string_chunk_insert(GStringChunk *chunk, const char *str)
{
if (!chunk || !str) {
return NULL;
-cr_Package *cr_parse_header(Header hdr, gint64 mtime, gint64 size,
- const char *checksum, const char *checksum_type,
- const char *location_href,
- const char *location_base, int changelog_limit,
- gint64 hdr_start, gint64 hdr_end)
+cr_Package *
+cr_parse_header(Header hdr, gint64 mtime, gint64 size,
+ const char *checksum, const char *checksum_type,
+ const char *location_href, const char *location_base,
+ int changelog_limit, gint64 hdr_start, gint64 hdr_end)
{
// Create new package structure
(rpmtdNext(filemodes) != -1))
{
cr_PackageFile *packagefile = cr_package_file_new();
- packagefile->name = safe_string_chunk_insert(pkg->chunk, rpmtdGetString(filenames));
+ packagefile->name = safe_string_chunk_insert(pkg->chunk,
+ rpmtdGetString(filenames));
packagefile->path = (dir_list) ? dir_list[(int) rpmtdGetNumber(indexes)] : "";
if (S_ISDIR(rpmtdGetNumber(filemodes))) {
packagefile->type = safe_string_chunk_insert(pkg->chunk, "");
}
- g_hash_table_replace(filenames_hashtable, (gpointer) rpmtdGetString(full_filenames), (gpointer) rpmtdGetString(full_filenames));
+ g_hash_table_replace(filenames_hashtable,
+ (gpointer) rpmtdGetString(full_filenames),
+ (gpointer) rpmtdGetString(full_filenames));
pkg->files = g_slist_prepend(pkg->files, packagefile);
}
pkg->files = g_slist_reverse (pkg->files);
GHashTable *provided_hashtable = g_hash_table_new(g_str_hash, g_str_equal);
// Hashtable with already processed files from requires
- GHashTable *ap_hashtable = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, free);
+ GHashTable *ap_hashtable = g_hash_table_new_full(g_str_hash,
+ g_str_equal,
+ NULL,
+ free);
int pcor_type;
for (pcor_type=0; pcor_type <= REQUIRES; pcor_type++) {
gint64 time = rpmtdGetNumber(changelogtimes);
cr_ChangelogEntry *changelog = cr_changelog_entry_new();
- changelog->author = safe_string_chunk_insert(pkg->chunk, rpmtdGetString(changelognames));
+ changelog->author = safe_string_chunk_insert(pkg->chunk,
+ rpmtdGetString(changelognames));
changelog->date = time;
- changelog->changelog = safe_string_chunk_insert(pkg->chunk, rpmtdGetString(changelogtexts));
+ changelog->changelog = safe_string_chunk_insert(pkg->chunk,
+ rpmtdGetString(changelogtexts));
// Remove space from end of author name
if (changelog->author) {
-struct cr_XmlStruct cr_xml_from_header(Header hdr, gint64 mtime, gint64 size,
+struct cr_XmlStruct
+cr_xml_from_header(Header hdr, gint64 mtime, gint64 size,
const char *checksum,
const char *checksum_type,
const char *location_href,
/** \ingroup parsehdr
* Read data from header and return filled cr_Package structure.
+ * All const char * params could be NULL.
* @param hdr Header
* @param mtime mtime of rpm file
* @param size size of rpm file (in bytes)
/** \ingroup parsehdr
* Read data from header and return struct cr_XmlStruct.
+ * All const char * params could be NULL.
* @param hdr Header
* @param mtime mtime of rpm file
* @param size size of rpm file (in bytes)
#include <unistd.h>
#include <rpm/rpmts.h>
#include <rpm/rpmfi.h>
+#include <rpm/rpmlib.h>
#include <rpm/rpmmacro.h>
#include "logging.h"
#include "constants.h"
-void cr_package_parser_init()
+void
+cr_package_parser_init()
{
if (cr_initialized)
return;
-void cr_package_parser_shutdown()
+void
+cr_package_parser_shutdown()
{
if (ts) {
rpmtsFree(ts);
}
-cr_Package *cr_package_from_file(const char *filename,
- cr_ChecksumType checksum_type,
- const char *location_href,
- const char *location_base,
- int changelog_limit,
- struct stat *stat_buf)
+cr_Package *
+cr_package_from_file(const char *filename,
+ cr_ChecksumType checksum_type,
+ const char *location_href,
+ const char *location_base,
+ int changelog_limit,
+ struct stat *stat_buf)
{
cr_Package *result = NULL;
const char *checksum_type_str;
FD_t fd = NULL;
fd = Fopen(filename, "r.ufdio");
if (!fd) {
- g_warning(MODULE"%s: Fopen of %s failed %s", __func__, filename, strerror(errno));
+ g_warning(MODULE"%s: Fopen of %s failed %s",
+ __func__, filename, strerror(errno));
return result;
}
if (rc != RPMRC_OK) {
switch (rc) {
case RPMRC_NOKEY:
- g_debug(MODULE"%s: %s: Public key is unavailable.", __func__, filename);
+ g_debug(MODULE"%s: %s: Public key is unavailable.",
+ __func__, filename);
break;
case RPMRC_NOTTRUSTED:
- g_debug(MODULE"%s: %s: Signature is OK, but key is not trusted.", __func__, filename);
+ g_debug(MODULE"%s: %s: Signature is OK, but key is not trusted.",
+ __func__, filename);
break;
default:
- g_warning(MODULE"%s: rpmReadPackageFile() error (%s)", __func__, strerror(errno));
+ g_warning(MODULE"%s: rpmReadPackageFile() error (%s)",
+ __func__, strerror(errno));
return result;
}
}
-struct cr_XmlStruct cr_xml_from_package_file(const char *filename,
- cr_ChecksumType checksum_type,
- const char *location_href,
- const char *location_base,
- int changelog_limit,
- struct stat *stat_buf)
+struct cr_XmlStruct
+cr_xml_from_package_file(const char *filename,
+ cr_ChecksumType checksum_type,
+ const char *location_href,
+ const char *location_base,
+ int changelog_limit,
+ struct stat *stat_buf)
{
const char *checksum_type_str;
if (rc != RPMRC_OK) {
switch (rc) {
case RPMRC_NOKEY:
- g_debug(MODULE"%s: %s: Public key is unavailable.", __func__, filename);
+ g_debug(MODULE"%s: %s: Public key is unavailable.",
+ __func__, filename);
break;
case RPMRC_NOTTRUSTED:
- g_debug(MODULE"%s: %s: Signature is OK, but key is not trusted.", __func__, filename);
+ g_debug(MODULE"%s: %s: Signature is OK, but key is not trusted.",
+ __func__, filename);
break;
default:
- g_warning(MODULE"%s: rpmReadPackageFile() error (%s)", __func__, strerror(errno));
+ g_warning(MODULE"%s: rpmReadPackageFile() error (%s)",
+ __func__, strerror(errno));
return result;
}
}
extern "C" {
#endif
-#include <rpm/rpmlib.h>
#include <glib.h>
#include "constants.h"
#include "package.h"
-#include "xml_dump.h"
/** \defgroup parsepkg Package parser API.
*/
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
+ * USA
*/
#include <glib.h>
#include <time.h>
#include <zlib.h>
#include <assert.h>
+#include <libxml/encoding.h>
+#include <libxml/xmlwriter.h>
#include "logging.h"
#include "misc.h"
#include "repomd.h"
do {
readed = cr_read(cwfile, (void *) buffer, BUFFER_SIZE);
if (readed == CR_CW_ERR) {
- g_debug(MODULE"%s: Error while read compressed file: %s", __func__, filename);
+ g_debug(MODULE"%s: Error while read compressed file: %s",
+ __func__, filename);
break;
}
g_checksum_update (checksum, buffer, readed);
cr_ChecksumType checksum_t = DEFAULT_CHECKSUM_ENUM_VAL;
if (checksum_type) {
- checksum_str = cr_get_checksum_name_str(*checksum_type);
+ checksum_str = cr_checksum_name_str(*checksum_type);
checksum_t = *checksum_type;
}
g_free(open_stat);
} else {
// Unknown compression
- g_warning(MODULE"%s: File \"%s\" compressed by an unsupported type of compression", __func__, path);
+ g_warning(MODULE"%s: File \"%s\" compressed by an unsupported type"
+ " of compression", __func__, path);
md->checksum_open_type = g_string_chunk_insert(md->chunk, "UNKNOWN");
- md->checksum_open = g_string_chunk_insert(md->chunk, "file_compressed_by_an_unsupported_type_of_compression");
+ md->checksum_open = g_string_chunk_insert(md->chunk,
+ "file_compressed_by_an_unsupported_type_of_compression");
md->size_open = -1;
}
}
cr_ChecksumType checksum_t = DEFAULT_CHECKSUM_ENUM_VAL;
if (checksum_type) {
- checksum_str = cr_get_checksum_name_str(*checksum_type);
+ checksum_str = cr_checksum_name_str(*checksum_type);
checksum_t = *checksum_type;
}
// Paths
- const char *suffix = cr_get_suffix(groupfile_compression);
+ const char *suffix = cr_compression_suffix(groupfile_compression);
gchar *clocation_href = g_strconcat(groupfile->location_href, suffix, NULL);
- cgroupfile->location_href = g_string_chunk_insert(cgroupfile->chunk, clocation_href);
+ cgroupfile->location_href = g_string_chunk_insert(cgroupfile->chunk,
+ clocation_href);
g_free(clocation_href);
gchar *path = g_strconcat(base_path, "/", groupfile->location_href, NULL);
xmlNewProp(data, BAD_CAST "type", BAD_CAST type);
- node = xmlNewTextChild(data, NULL, BAD_CAST "checksum", BAD_CAST md->checksum);
+ node = xmlNewTextChild(data, NULL, BAD_CAST "checksum",
+ BAD_CAST md->checksum);
xmlNewProp(node, BAD_CAST "type", BAD_CAST md->checksum_type);
if (md->checksum_open) {
- node = xmlNewTextChild(data, NULL, BAD_CAST "open-checksum", BAD_CAST md->checksum_open);
+ node = xmlNewTextChild(data, NULL, BAD_CAST "open-checksum",
+ BAD_CAST md->checksum_open);
xmlNewProp(node, BAD_CAST "type", BAD_CAST md->checksum_open_type);
}
if (g_str_has_suffix((char *)type, "_db")) {
g_snprintf(str_buffer, STR_BUFFER_SIZE, "%d", md->db_ver);
- xmlNewChild(data, NULL, BAD_CAST "database_version", BAD_CAST str_buffer);
+ xmlNewChild(data, NULL, BAD_CAST "database_version",
+ BAD_CAST str_buffer);
}
}
char *
repomd_xml_dump(long revision, cr_RepomdRecord pri_xml, cr_RepomdRecord fil_xml,
- cr_RepomdRecord oth_xml, cr_RepomdRecord pri_sqlite,
- cr_RepomdRecord fil_sqlite, cr_RepomdRecord oth_sqlite,
- cr_RepomdRecord groupfile, cr_RepomdRecord cgroupfile,
- cr_RepomdRecord update_info)
+ cr_RepomdRecord oth_xml, cr_RepomdRecord pri_sqlite,
+ cr_RepomdRecord fil_sqlite, cr_RepomdRecord oth_sqlite,
+ cr_RepomdRecord groupfile, cr_RepomdRecord cgroupfile,
+ cr_RepomdRecord update_info)
{
xmlDocPtr doc;
xmlNodePtr root;
// Dump IT!
char *result;
- //xmlDocDumpFormatMemory(doc, (xmlChar **) &result, NULL, FORMAT_XML);
- xmlDocDumpFormatMemoryEnc(doc, (xmlChar **) &result, NULL, XML_ENC, FORMAT_XML);
+ xmlDocDumpFormatMemoryEnc(doc,
+ (xmlChar **) &result,
+ NULL,
+ XML_ENC,
+ FORMAT_XML);
// Clean up
}
}
- gchar *new_location_href = g_strconcat(location_href_path_prefix, md->checksum, "-", location_href_filename_only, NULL);
+ gchar *new_location_href = g_strconcat(location_href_path_prefix,
+ md->checksum,
+ "-",
+ location_href_filename_only,
+ NULL);
gchar *new_path = g_strconcat(base_path, "/", new_location_href, NULL);
g_free(location_href_path_prefix);
}
long revision = (long) time(NULL);
- return repomd_xml_dump(revision, pri_xml, fil_xml, oth_xml, pri_sqlite, fil_sqlite, oth_sqlite, groupfile, cgroupfile, update_info);
+ return repomd_xml_dump(revision,
+ pri_xml,
+ fil_xml,
+ oth_xml,
+ pri_sqlite,
+ fil_sqlite,
+ oth_sqlite,
+ groupfile,
+ cgroupfile,
+ update_info);
}
extern "C" {
#endif
-#include <libxml/encoding.h>
-#include <libxml/xmlwriter.h>
#include "compression_wrapper.h"
#include "package.h"
return;
}
- const char *deps[] = { "requires", "provides", "conflicts", "obsoletes", NULL };
int i;
+ const char *deps[] = { "requires",
+ "provides",
+ "conflicts",
+ "obsoletes",
+ NULL
+ };
const char *pkgindexsql = "CREATE INDEX IF NOT EXISTS pkg%s on %s (pkgKey)";
const char *nameindexsql = "CREATE INDEX IF NOT EXISTS %sname ON %s (name)";
* @param err **GError
* @return cr_DbPrimaryStatements object
*/
-cr_DbPrimaryStatements cr_prepare_primary_db_statements(sqlite3 *db, GError **err);
+cr_DbPrimaryStatements cr_prepare_primary_db_statements(sqlite3 *db,
+ GError **err);
/** \ingroup sqlite
* Prepare compiled statements for use in the cr_add_filelists_pkg_db function.
* @return cr_DbFilelistsStatements object
*/
cr_DbFilelistsStatements cr_prepare_filelists_db_statements(sqlite3 *db,
- GError **err);
+ GError **err);
/** \ingroup sqlite
* Prepare compiled statements for use in the cr_add_other_pkg_db function.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
+ * USA
*/
#include <glib.h>
#define MODULE "xml_dump: "
-void cr_dump_files(xmlNodePtr node, cr_Package *package, int primary)
+void
+cr_dump_files(xmlNodePtr node, cr_Package *package, int primary)
{
if (!node || !package->files) {
return;
// ************************************
xmlNodePtr file_node;
- file_node = xmlNewTextChild(node, NULL, BAD_CAST "file", BAD_CAST fullname);
+ file_node = xmlNewTextChild(node,
+ NULL,
+ BAD_CAST "file",
+ BAD_CAST fullname);
g_free(fullname);
// Write type (skip type if type value is empty of "file")
-struct cr_XmlStruct cr_xml_dump(cr_Package *pkg)
+struct cr_XmlStruct
+cr_xml_dump(cr_Package *pkg)
{
struct cr_XmlStruct result;
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
+ * USA
*/
#include <glib.h>
#define FORMAT_LEVEL 0
-void dump_filelists_items(xmlNodePtr root, cr_Package *package)
+void
+dump_filelists_items(xmlNodePtr root, cr_Package *package)
{
/***********************************
Element: package
************************************/
// Add pkgid attribute
- xmlNewProp(root, BAD_CAST "pkgid", BAD_CAST ((package->pkgId) ? package->pkgId : ""));
+ xmlNewProp(root, BAD_CAST "pkgid",
+ BAD_CAST ((package->pkgId) ? package->pkgId : ""));
// Add name attribute
- xmlNewProp(root, BAD_CAST "name", BAD_CAST ((package->name) ? package->name : ""));
+ xmlNewProp(root, BAD_CAST "name",
+ BAD_CAST ((package->name) ? package->name : ""));
// Add arch attribute
- xmlNewProp(root, BAD_CAST "arch", BAD_CAST ((package->arch) ? package->arch : ""));
+ xmlNewProp(root, BAD_CAST "arch",
+ BAD_CAST ((package->arch) ? package->arch : ""));
/***********************************
version = xmlNewChild(root, NULL, BAD_CAST "version", NULL);
// Write version attribute epoch
- xmlNewProp(version, BAD_CAST "epoch", BAD_CAST ((package->epoch) ? package->epoch : ""));
+ xmlNewProp(version, BAD_CAST "epoch",
+ BAD_CAST ((package->epoch) ? package->epoch : ""));
// Write version attribute ver
- xmlNewProp(version, BAD_CAST "ver", BAD_CAST ((package->version) ? package->version : ""));
+ xmlNewProp(version, BAD_CAST "ver",
+ BAD_CAST ((package->version) ? package->version : ""));
// Write version attribute rel
- xmlNewProp(version, BAD_CAST "rel", BAD_CAST ((package->release) ? package->release : ""));
+ xmlNewProp(version, BAD_CAST "rel",
+ BAD_CAST ((package->release) ? package->release : ""));
// Files dump
}
-char *cr_xml_dump_filelists(cr_Package *package)
+char *
+cr_xml_dump_filelists(cr_Package *package)
{
if (!package)
return NULL;
// Seems to be little bit faster than xmlDocDumpFormatMemory
xmlNodeDump(buf, NULL, root, FORMAT_LEVEL, FORMAT_XML);
assert(buf->content);
- result = g_strndup((char *) buf->content, (buf->use+1)); // g_strndup allocate (buf->use+1
+ result = g_strndup((char *) buf->content, (buf->use+1));
result[buf->use] = '\n';
result[buf->use+1] = '\0';
xmlBufferFree(buf);
extern "C" {
#endif
-#include <libxml/xmlwriter.h>
#include "package.h"
/**
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
+ * USA
*/
#include <glib.h>
#define DATE_MAX_LEN 32
-void dump_changelog(xmlNodePtr root, cr_Package *package)
+void
+dump_changelog(xmlNodePtr root, cr_Package *package)
{
if (!package->changelogs) {
return;
xmlNodePtr changelog;
// Add changelog element
- changelog = xmlNewTextChild(root, NULL, BAD_CAST "changelog", BAD_CAST ((entry->changelog) ? entry->changelog : ""));
+ changelog = xmlNewTextChild(root,
+ NULL,
+ BAD_CAST "changelog",
+ BAD_CAST ((entry->changelog) ? entry->changelog : ""));
// Write param author
- xmlNewProp(changelog, BAD_CAST "author", BAD_CAST ((entry->author) ? entry->author : ""));
+ xmlNewProp(changelog,
+ BAD_CAST "author",
+ BAD_CAST ((entry->author) ? entry->author : ""));
// Write param date
char date_str[DATE_MAX_LEN];
}
-void dump_other_items(xmlNodePtr root, cr_Package *package)
+void
+dump_other_items(xmlNodePtr root, cr_Package *package)
{
/***********************************
Element: package
************************************/
// Add pkgid attribute
- xmlNewProp(root, BAD_CAST "pkgid", BAD_CAST ((package->pkgId) ? package->pkgId : ""));
+ xmlNewProp(root, BAD_CAST "pkgid",
+ BAD_CAST ((package->pkgId) ? package->pkgId : ""));
// Add name attribute
- xmlNewProp(root, BAD_CAST "name", BAD_CAST ((package->name) ? package->name : ""));
+ xmlNewProp(root, BAD_CAST "name",
+ BAD_CAST ((package->name) ? package->name : ""));
// Add arch attribute
- xmlNewProp(root, BAD_CAST "arch", BAD_CAST ((package->arch) ? package->arch : ""));
+ xmlNewProp(root, BAD_CAST "arch",
+ BAD_CAST ((package->arch) ? package->arch : ""));
/***********************************
version = xmlNewChild(root, NULL, BAD_CAST "version", NULL);
// Write version attribute epoch
- xmlNewProp(version, BAD_CAST "epoch", BAD_CAST ((package->epoch) ? package->epoch : ""));
+ xmlNewProp(version, BAD_CAST "epoch",
+ BAD_CAST ((package->epoch) ? package->epoch : ""));
// Write version attribute ver
- xmlNewProp(version, BAD_CAST "ver", BAD_CAST ((package->version) ? package->version : ""));
+ xmlNewProp(version, BAD_CAST "ver",
+ BAD_CAST ((package->version) ? package->version : ""));
// Write version attribute rel
- xmlNewProp(version, BAD_CAST "rel", BAD_CAST ((package->release) ? package->release : ""));
+ xmlNewProp(version, BAD_CAST "rel",
+ BAD_CAST ((package->release) ? package->release : ""));
// Changelog dump
}
-char *cr_xml_dump_other(cr_Package *package)
+char *
+cr_xml_dump_other(cr_Package *package)
{
if (!package)
return NULL;
// Seems to be little bit faster than xmlDocDumpFormatMemory
xmlNodeDump(buf, NULL, root, FORMAT_LEVEL, FORMAT_XML);
assert(buf->content);
- result = g_strndup((char *) buf->content, (buf->use+1)); // g_strndup allocate (buf->use+1
+ result = g_strndup((char *) buf->content, (buf->use+1));
result[buf->use] = '\n';
result[buf->use+1] = '\0';
xmlBufferFree(buf);
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
+ * USA
*/
#include <glib.h>
#define SIZE_STR_MAX_LEN 32
-void dump_pco(xmlNodePtr root, cr_Package *package, int pcotype)
+void
+dump_pco(xmlNodePtr root, cr_Package *package, int pcotype)
{
const char *elem_name;
GSList *files = NULL;
-void dump_base_items(xmlNodePtr root, cr_Package *package)
+void
+dump_base_items(xmlNodePtr root, cr_Package *package)
{
/***********************************
Element: package
Element: name
************************************/
- xmlNewTextChild(root, NULL, BAD_CAST "name", BAD_CAST ((package->name) ? package->name : ""));
+ xmlNewTextChild(root, NULL, BAD_CAST "name",
+ BAD_CAST ((package->name) ? package->name : ""));
/***********************************
Element: arch
************************************/
- xmlNewTextChild(root, NULL, BAD_CAST "arch", BAD_CAST ((package->arch) ? package->arch : ""));
+ xmlNewTextChild(root, NULL, BAD_CAST "arch",
+ BAD_CAST ((package->arch) ? package->arch : ""));
/***********************************
version = xmlNewChild(root, NULL, BAD_CAST "version", NULL);
// Write version attribute epoch
- xmlNewProp(version, BAD_CAST "epoch", BAD_CAST ((package->epoch) ? package->epoch : ""));
+ xmlNewProp(version, BAD_CAST "epoch",
+ BAD_CAST ((package->epoch) ? package->epoch : ""));
// Write version attribute ver
- xmlNewProp(version, BAD_CAST "ver", BAD_CAST ((package->version) ? package->version : ""));
+ xmlNewProp(version, BAD_CAST "ver",
+ BAD_CAST ((package->version) ? package->version : ""));
// Write version attribute rel
- xmlNewProp(version, BAD_CAST "rel", BAD_CAST ((package->release) ? package->release : ""));
+ xmlNewProp(version, BAD_CAST "rel",
+ BAD_CAST ((package->release) ? package->release : ""));
/***********************************
xmlNodePtr checksum;
- checksum = xmlNewTextChild(root, NULL, BAD_CAST "checksum", BAD_CAST ((package->pkgId) ? package->pkgId : ""));
+ checksum = xmlNewTextChild(root, NULL, BAD_CAST "checksum",
+ BAD_CAST ((package->pkgId) ? package->pkgId : ""));
// Write checksum attribute checksum_type
- xmlNewProp(checksum, BAD_CAST "type", BAD_CAST ((package->checksum_type) ? package->checksum_type : ""));
+ xmlNewProp(checksum, BAD_CAST "type",
+ BAD_CAST ((package->checksum_type) ? package->checksum_type : ""));
// Write checksum attribute pkgid
xmlNewProp(checksum, BAD_CAST "pkgid", BAD_CAST "YES");
Element: summary
************************************/
- xmlNewTextChild(root, NULL, BAD_CAST "summary", BAD_CAST ((package->summary) ? package->summary : ""));
+ xmlNewTextChild(root, NULL, BAD_CAST "summary",
+ BAD_CAST ((package->summary) ? package->summary : ""));
/***********************************
Element: description
************************************/
- xmlNewTextChild(root, NULL, BAD_CAST "description", BAD_CAST ((package->description) ? package->description : ""));
+ xmlNewTextChild(root, NULL, BAD_CAST "description",
+ BAD_CAST ((package->description) ? package->description : ""));
/***********************************
Element: packager
************************************/
- xmlNewTextChild(root, NULL, BAD_CAST "packager", BAD_CAST ((package->rpm_packager) ? package->rpm_packager : ""));
+ xmlNewTextChild(root, NULL, BAD_CAST "packager",
+ BAD_CAST ((package->rpm_packager) ? package->rpm_packager : ""));
/***********************************
Element: url
************************************/
- xmlNewTextChild(root, NULL, BAD_CAST "url", BAD_CAST ((package->url) ? package->url : ""));
+ xmlNewTextChild(root, NULL, BAD_CAST "url",
+ BAD_CAST ((package->url) ? package->url : ""));
/***********************************
time = xmlNewChild(root, NULL, BAD_CAST "time", NULL);
// Write time attribute file
- g_snprintf(date_str, DATE_STR_MAX_LEN, "%lld", (long long int) package->time_file);
+ g_snprintf(date_str, DATE_STR_MAX_LEN, "%lld",
+ (long long int) package->time_file);
xmlNewProp(time, BAD_CAST "file", BAD_CAST date_str);
// Write time attribute build
- g_snprintf(date_str, DATE_STR_MAX_LEN, "%lld", (long long int) package->time_build);
+ g_snprintf(date_str, DATE_STR_MAX_LEN, "%lld",
+ (long long int) package->time_build);
xmlNewProp(time, BAD_CAST "build", BAD_CAST date_str);
size = xmlNewChild(root, NULL, BAD_CAST "size", NULL);
// Write size attribute package
- g_snprintf(size_str, SIZE_STR_MAX_LEN, "%lld", (long long int) package->size_package);
+ g_snprintf(size_str, SIZE_STR_MAX_LEN, "%lld",
+ (long long int) package->size_package);
xmlNewProp(size, BAD_CAST "package", BAD_CAST size_str);
// Write size attribute installed
- g_snprintf(size_str, SIZE_STR_MAX_LEN, "%lld", (long long int) package->size_installed);
+ g_snprintf(size_str, SIZE_STR_MAX_LEN, "%lld",
+ (long long int) package->size_installed);
xmlNewProp(size, BAD_CAST "installed", BAD_CAST size_str);
// Write size attribute archive
- g_snprintf(size_str, SIZE_STR_MAX_LEN, "%lld", (long long int) package->size_archive);
+ g_snprintf(size_str, SIZE_STR_MAX_LEN, "%lld",
+ (long long int) package->size_archive);
xmlNewProp(size, BAD_CAST "archive", BAD_CAST size_str);
location = xmlNewChild(root, NULL, BAD_CAST "location", NULL);
-// Write location attribute base
+ // Write location attribute base
if (package->location_base && package->location_base[0] != '\0') {
- xmlNewProp(location, BAD_CAST "xml:base", BAD_CAST package->location_base);
+ xmlNewProp(location,
+ BAD_CAST "xml:base",
+ BAD_CAST package->location_base);
}
// Write location attribute href
- xmlNewProp(location, BAD_CAST "href", BAD_CAST ((package->location_href) ? package->location_href : ""));
+ xmlNewProp(location, BAD_CAST "href",
+ BAD_CAST ((package->location_href) ? package->location_href : ""));
/***********************************
Element: license
************************************/
- xmlNewTextChild(format, NULL, BAD_CAST "rpm:license", BAD_CAST ((package->rpm_license) ? package->rpm_license : ""));
+ xmlNewTextChild(format, NULL, BAD_CAST "rpm:license",
+ BAD_CAST ((package->rpm_license) ? package->rpm_license : ""));
/***********************************
Element: vendor
************************************/
- xmlNewTextChild(format, NULL, BAD_CAST "rpm:vendor", BAD_CAST ((package->rpm_vendor) ? package->rpm_vendor : ""));
+ xmlNewTextChild(format, NULL, BAD_CAST "rpm:vendor",
+ BAD_CAST ((package->rpm_vendor) ? package->rpm_vendor : ""));
/***********************************
Element: group
************************************/
- xmlNewTextChild(format, NULL, BAD_CAST "rpm:group", BAD_CAST ((package->rpm_group) ? package->rpm_group : ""));
+ xmlNewTextChild(format, NULL, BAD_CAST "rpm:group",
+ BAD_CAST ((package->rpm_group) ? package->rpm_group : ""));
/***********************************
Element: buildhost
************************************/
- xmlNewTextChild(format, NULL, BAD_CAST "rpm:buildhost", BAD_CAST ((package->rpm_buildhost) ? package->rpm_buildhost : ""));
+ xmlNewTextChild(format, NULL, BAD_CAST "rpm:buildhost",
+ BAD_CAST ((package->rpm_buildhost) ? package->rpm_buildhost : ""));
/***********************************
Element: sourcerpm
************************************/
- xmlNewTextChild(format, NULL, BAD_CAST "rpm:sourcerpm", BAD_CAST ((package->rpm_sourcerpm) ? package->rpm_sourcerpm : ""));
+ xmlNewTextChild(format, NULL, BAD_CAST "rpm:sourcerpm",
+ BAD_CAST ((package->rpm_sourcerpm) ? package->rpm_sourcerpm : ""));
/***********************************
header_range = xmlNewChild(format, NULL, BAD_CAST "rpm:header-range", NULL);
// Write header-range attribute hdrstart
- g_snprintf(size_str, SIZE_STR_MAX_LEN, "%lld", (long long int) package->rpm_header_start);
+ g_snprintf(size_str,
+ SIZE_STR_MAX_LEN,
+ "%lld",
+ (long long int) package->rpm_header_start);
xmlNewProp(header_range, BAD_CAST "start", BAD_CAST size_str);
// Write header-range attribute hdrend
- g_snprintf(size_str, SIZE_STR_MAX_LEN, "%lld", (long long int) package->rpm_header_end);
+ g_snprintf(size_str,
+ SIZE_STR_MAX_LEN,
+ "%lld",
+ (long long int) package->rpm_header_end);
xmlNewProp(header_range, BAD_CAST "end", BAD_CAST size_str);
-char *cr_xml_dump_primary(cr_Package *package)
+char *
+cr_xml_dump_primary(cr_Package *package)
{
if (!package)
return NULL;
// Seems to be little bit faster than xmlDocDumpFormatMemory
xmlNodeDump(buf, NULL, root, FORMAT_LEVEL, FORMAT_XML);
assert(buf->content);
- result = g_strndup((char *) buf->content, (buf->use+1)); // g_strndup allocate (buf->use+1)+1
+ result = g_strndup((char *) buf->content, (buf->use+1));
result[buf->use] = '\n';
result[buf->use+1] = '\0';
xmlBufferFree(buf);
-static void test_cr_get_suffix(void)
+static void test_cr_compression_suffix(void)
{
const char *suffix;
- suffix = cr_get_suffix(CR_CW_AUTO_DETECT_COMPRESSION);
+ suffix = cr_compression_suffix(CR_CW_AUTO_DETECT_COMPRESSION);
g_assert(!suffix);
- suffix = cr_get_suffix(CR_CW_UNKNOWN_COMPRESSION);
+ suffix = cr_compression_suffix(CR_CW_UNKNOWN_COMPRESSION);
g_assert(!suffix);
- suffix = cr_get_suffix(CR_CW_NO_COMPRESSION);
+ suffix = cr_compression_suffix(CR_CW_NO_COMPRESSION);
g_assert(!suffix);
- suffix = cr_get_suffix(CR_CW_GZ_COMPRESSION);
+ suffix = cr_compression_suffix(CR_CW_GZ_COMPRESSION);
g_assert_cmpstr(suffix, ==, ".gz");
- suffix = cr_get_suffix(CR_CW_BZ2_COMPRESSION);
+ suffix = cr_compression_suffix(CR_CW_BZ2_COMPRESSION);
g_assert_cmpstr(suffix, ==, ".bz2");
- suffix = cr_get_suffix(CR_CW_XZ_COMPRESSION);
+ suffix = cr_compression_suffix(CR_CW_XZ_COMPRESSION);
g_assert_cmpstr(suffix, ==, ".xz");
}
{
g_test_init(&argc, &argv, NULL);
- g_test_add_func("/compression_wrapper/test_cr_get_suffix", test_cr_get_suffix);
+ g_test_add_func("/compression_wrapper/test_cr_compression_suffix", test_cr_compression_suffix);
g_test_add_func("/compression_wrapper/test_cr_detect_compression", test_cr_detect_compression);
g_test_add_func("/compression_wrapper/test_cr_detect_compression_bad_suffix", test_cr_detect_compression_bad_suffix);
g_test_add_func("/compression_wrapper/test_cr_read_with_autodetection", test_cr_read_with_autodetection);
g_assert_cmpint(pkg->time_file, ==, 1334667003);
g_assert_cmpint(pkg->time_build, ==, 1334667003);
g_assert_cmpstr(pkg->rpm_license, ==, "LGPLv2");
- g_assert_cmpstr(pkg->rpm_vendor, ==, "");
+ g_assert_cmpstr(pkg->rpm_vendor, ==, NULL);
g_assert_cmpstr(pkg->rpm_group, ==, "Applications/System");
g_assert_cmpstr(pkg->rpm_buildhost, ==, "localhost.localdomain");
g_assert_cmpstr(pkg->rpm_sourcerpm, ==, "super_kernel-6.0.1-2.src.rpm");
g_assert_cmpint(pkg->rpm_header_start, ==, 280);
g_assert_cmpint(pkg->rpm_header_end, ==, 2637);
- g_assert_cmpstr(pkg->rpm_packager, ==, "");
+ g_assert_cmpstr(pkg->rpm_packager, ==, NULL);
g_assert_cmpint(pkg->size_package, ==, 2845);
g_assert_cmpint(pkg->size_installed, ==, 0);
g_assert_cmpint(pkg->size_archive, ==, 404);
}
-static void test_cr_get_checksum_name_str(void)
+static void test_cr_checksum_name_str(void)
{
const char *checksum_name;
- checksum_name = cr_get_checksum_name_str(CR_CHECKSUM_MD5);
+ checksum_name = cr_checksum_name_str(CR_CHECKSUM_MD5);
g_assert_cmpstr(checksum_name, ==, "md5");
- checksum_name = cr_get_checksum_name_str(CR_CHECKSUM_SHA1);
+ checksum_name = cr_checksum_name_str(CR_CHECKSUM_SHA1);
g_assert_cmpstr(checksum_name, ==, "sha1");
- checksum_name = cr_get_checksum_name_str(CR_CHECKSUM_SHA256);
+ checksum_name = cr_checksum_name_str(CR_CHECKSUM_SHA256);
g_assert_cmpstr(checksum_name, ==, "sha256");
- checksum_name = cr_get_checksum_name_str(244);
+ checksum_name = cr_checksum_name_str(244);
g_assert_cmpstr(checksum_name, ==, NULL);
}
g_test_add_func("/misc/test_cr_is_primary", test_cr_is_primary);
g_test_add_func("/misc/test_cr_compute_file_checksum", test_cr_compute_file_checksum);
g_test_add_func("/misc/test_cr_get_header_byte_range", test_cr_get_header_byte_range);
- g_test_add_func("/misc/test_cr_get_checksum_name_str", test_cr_get_checksum_name_str);
+ g_test_add_func("/misc/test_cr_checksum_name_str", test_cr_checksum_name_str);
g_test_add_func("/misc/test_cr_get_filename", test_cr_get_filename);
g_test_add("/misc/copyfiletest_test_empty_file", Copyfiletest, NULL, copyfiletest_setup, copyfiletest_test_empty_file, copyfiletest_teardown);
g_test_add("/misc/copyfiletest_test_text_file", Copyfiletest, NULL, copyfiletest_setup, copyfiletest_test_text_file, copyfiletest_teardown);
projects / services / createrepo_c.git / commitdiff