#define gzbuffer(a,b) 0
#endif
+cr_ContentStat *
+cr_contentstat_new(cr_ChecksumType type, GError **err)
+{
+ cr_ContentStat *cstat;
+ cr_ChecksumCtx *checksum;
+ GError *tmp_err = NULL;
+
+ assert(!err || *err == NULL);
+
+ if (type == CR_CHECKSUM_UNKNOWN) {
+ checksum = NULL;
+ } else {
+ checksum = cr_checksum_new(type, &tmp_err);
+ if (tmp_err) {
+ g_propagate_error(err, tmp_err);
+ return NULL;
+ }
+ }
+
+ cstat = g_malloc0(sizeof(cr_ContentStat));
+ cstat->checksum = checksum;
+
+ return cstat;
+}
+
+char *
+cr_contentstat_free(cr_ContentStat *cstat, GError **err)
+{
+ char *checksum_str = NULL;
+ GError *tmp_err = NULL;
+
+ assert(!err || *err == NULL);
+
+ if (!cstat)
+ return NULL;
+
+ if (cstat->checksum) {
+ checksum_str = cr_checksum_final(cstat->checksum, &tmp_err);
+ if (tmp_err)
+ g_propagate_error(err, tmp_err);
+ }
+
+ g_free(cstat);
+ return checksum_str;
+}
typedef struct {
lzma_stream stream;
unsigned char buffer[XZ_BUFFER_SIZE];
} XzFile;
-
-
cr_CompressionType
cr_detect_compression(const char *filename, GError **err)
{
CR_FILE *
-cr_open(const char *filename,
- cr_OpenMode mode,
- cr_CompressionType comtype,
- GError **err)
+cr_open_with_stats(const char *filename,
+ cr_OpenMode mode,
+ cr_CompressionType comtype,
+ cr_ContentStat *stat,
+ GError **err)
{
CR_FILE *file = NULL;
cr_CompressionType type = comtype;
int
cr_close(CR_FILE *cr_file, GError **err)
{
- int ret = CR_CW_ERR;
+ int ret = CRE_ERROR;
int rc;
assert(!err || *err == NULL);
switch (cr_file->type) {
case (CR_CW_NO_COMPRESSION): // ---------------------------------------
- if (fclose((FILE *) cr_file->FILE) == 0)
- ret = CR_CW_OK;
- else
+ if (fclose((FILE *) cr_file->FILE) == 0) {
+ ret = CRE_OK;
+ } else {
+ ret = CRE_IO;
g_set_error(err, CR_COMPRESSION_WRAPPER_ERROR, CRE_IO,
"fclose(): %s", strerror(errno));
+ }
break;
case (CR_CW_GZ_COMPRESSION): // ---------------------------------------
rc = gzclose((gzFile) cr_file->FILE);
if (rc == Z_OK)
- ret = CR_CW_OK;
+ ret = CRE_OK;
else {
const char *err_msg;
switch (rc) {
default:
err_msg = "error";
}
+
+ ret = CRE_GZ;
g_set_error(err, CR_COMPRESSION_WRAPPER_ERROR, CRE_GZ,
"gzclose(): %s", err_msg);
}
BZ2_SKIP_FFLUSH, NULL, NULL);
if (rc == BZ_OK) {
- ret = CR_CW_OK;
+ ret = CRE_OK;
} else {
const char *err_msg;
err_msg = "other error";
}
+ ret = CRE_BZ2;
g_set_error(err, CR_COMPRESSION_WRAPPER_ERROR, CRE_BZ2,
"Bz2 error: %s", err_msg);
}
break;
}
+ ret = CRE_XZ;
g_set_error(err, CR_COMPRESSION_WRAPPER_ERROR, CRE_XZ,
"XZ: lzma_code() error (%d): %s",
rc, err_msg);
size_t olen = XZ_BUFFER_SIZE - stream->avail_out;
if (fwrite(xz_file->buffer, 1, olen, xz_file->file) != olen) {
// Error while writing
+ ret = CRE_XZ;
g_set_error(err, CR_COMPRESSION_WRAPPER_ERROR, CRE_XZ,
"XZ: fwrite() error: %s", strerror(errno));
break;
if(rc == LZMA_STREAM_END) {
// Everything all right
- ret = CR_CW_OK;
+ ret = CRE_OK;
break;
}
}
} else {
- ret = CR_CW_OK;
+ ret = CRE_OK;
}
fclose(xz_file->file);
}
default: // -----------------------------------------------------------
+ ret = CRE_BADARG;
g_set_error(err, CR_COMPRESSION_WRAPPER_ERROR, CRE_BADARG,
"Bad compressed file type");
break;
g_free(cr_file);
- assert(!err || (ret == CR_CW_ERR && *err != NULL)
- || (ret != CR_CW_ERR && *err == NULL));
+ assert(!err || (ret != CRE_OK && *err != NULL)
+ || (ret == CRE_OK && *err == NULL));
return ret;
}
assert(!err || *err == NULL);
if (!str)
- return CR_CW_OK;
+ return 0;
if (cr_file->mode != CR_CW_MODE_WRITE) {
g_set_error(err, CR_COMPRESSION_WRAPPER_ERROR, CRE_BADARG,
case (CR_CW_NO_COMPRESSION): // ---------------------------------------
if (fputs(str, (FILE *) cr_file->FILE) != EOF) {
- ret = CR_CW_OK;
+ ret = 0;
} else {
g_set_error(err, CR_COMPRESSION_WRAPPER_ERROR, CRE_IO,
"fputs(): %s", strerror(errno));
case (CR_CW_GZ_COMPRESSION): // ---------------------------------------
if (gzputs((gzFile) cr_file->FILE, str) != -1) {
- ret = CR_CW_OK;
+ ret = 0;
} else {
g_set_error(err, CR_COMPRESSION_WRAPPER_ERROR, CRE_GZ,
"gzputs(): %s", cr_gz_strerror((gzFile) cr_file->FILE));
len = strlen(str);
ret = cr_write(cr_file, str, len, err);
if (ret == (int) len)
- ret = CR_CW_OK;
+ ret = 0;
else
ret = CR_CW_ERR;
break;
extern "C" {
#endif
+#include "checksum.h"
+
/** \defgroup compression_wrapper Wrapper for compressed file.
* \addtogroup compression_wrapper
* @{
CR_CW_MODE_SENTINEL, /*!< Sentinel of the list */
} cr_OpenMode;
+/** Stat build about open content during compression (writting).
+ */
+typedef struct {
+ gint64 size; /*!< Size of content */
+ cr_ChecksumCtx *checksum; /*!< Checksum context */
+} cr_ContentStat;
+
+/** Creates new cr_ContentStat object
+ * @param type Type of checksum. (if CR_CHECKSUM_UNKNOWN is used,
+ * no checksum calculation will be done)
+ * @param err GError **
+ * @return cr_ContentStat object
+ */
+cr_ContentStat *cr_contentstat_new(cr_ChecksumType type, GError **err);
+
+/** Frees cr_ContentStat object.
+ * @param cstat cr_ContentStat object
+ * @param err GError **
+ * @return checksum or NULL on error or if checksum calculation
+ * was disabled (CR_CHECKSUM_UNKNOWN was used)
+ */
+char *cr_contentstat_free(cr_ContentStat *cstat, GError **err);
/** Structure represents a compressed file.
*/
typedef struct {
- cr_CompressionType type; /*!< Type of compression */
- void *FILE; /*!< Pointer to gzFile, BZFILE or plain FILE */
- cr_OpenMode mode; /*!< Mode */
+ cr_CompressionType type; /*!< Type of compression */
+ void *FILE; /*!< Pointer to gzFile, BZFILE or plain FILE */
+ cr_OpenMode mode; /*!< Mode */
+ cr_ContentStat *stat; /*!< Content stats */
} CR_FILE;
-#define CR_CW_OK 0 /*!< Return value - Everything all right */
-#define CR_CW_ERR -1 /*!< Return value - Error */
+#define CR_CW_ERR -1 /*!< Return value - Error */
/** Returns a common suffix for the specified cr_CompressionType.
* @param comtype compression type
* @param err GError **
* @return pointer to a CR_FILE or NULL
*/
-CR_FILE *cr_open(const char *filename,
- cr_OpenMode mode,
- cr_CompressionType comtype,
- GError **err);
+#define cr_open(FILENAME, MODE, COMPRESSION, ERR) \
+ cr_open_with_stats(FILENAME, MODE, COMPRESSION, NULL, ERR)
+
+/** Open/Create the specified file. For writting is possible pass
+ * a cr_ContentStat object and after cr_close() get stats of
+ * an open content (stats of uncompressed content).
+ * @param filename filename
+ * @param mode open mode
+ * @param comtype type of compression
+ * @param stat cr_ContentStat object
+ * @param err GError **
+ * @return pointer to a CR_FILE or NULL
+ */
+CR_FILE *cr_open_with_stats(const char *filename,
+ cr_OpenMode mode,
+ cr_CompressionType comtype,
+ cr_ContentStat *stat,
+ GError **err);
/** Reads an array of len bytes from the CR_FILE.
* @param cr_file CR_FILE pointer
* @param cr_file CR_FILE pointer
* @param format format string
* @param ... list of additional arguments as specified in format
- * @return CR_CW_OK or CR_CW_ERR
+ * @return Number of bytes written or CR_CW_ERR (-1)
*/
int cr_printf(GError **err, CR_FILE *cr_file, const char *format, ...);
/** Closes the CR_FILE.
* @param cr_file CR_FILE pointer
* @param err GError **
- * @return CR_CW_OK or CR_CW_ERR
+ * @return cr_Error code
*/
int cr_close(CR_FILE *cr_file, GError **err);
#define FILE_COMPRESSED_1_XZ_BAD_SUFFIX TEST_COMPRESSED_FILES_PATH"/01_plain.foo3"
+static void
+test_cr_contentstat(void)
+{
+ char *checksum;
+ cr_ContentStat *cs = NULL;
+ GError *tmp_err = NULL;
+
+ cs = cr_contentstat_new(CR_CHECKSUM_UNKNOWN, NULL);
+ g_assert(cs);
+ checksum = cr_contentstat_free(cs, NULL);
+ g_assert(!checksum);
+ cs = NULL;
+
+ cs = cr_contentstat_new(CR_CHECKSUM_UNKNOWN, &tmp_err);
+ g_assert(cs);
+ g_assert(!tmp_err);
+ checksum = cr_contentstat_free(cs, &tmp_err);
+ g_assert(!checksum);
+ g_assert(!tmp_err);
+ cs = NULL;
+
+ cs = cr_contentstat_new(CR_CHECKSUM_SHA256, NULL);
+ g_assert(cs);
+ checksum = cr_contentstat_free(cs, NULL);
+ g_assert(checksum);
+ g_assert_cmpstr(checksum, ==, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649"
+ "b934ca495991b7852b855");
+ g_free(checksum);
+ cs = NULL;
+ checksum = NULL;
+
+ cs = cr_contentstat_new(CR_CHECKSUM_SHA256, &tmp_err);
+ g_assert(cs);
+ g_assert(!tmp_err);
+ checksum = cr_contentstat_free(cs, &tmp_err);
+ g_assert(!tmp_err);
+ g_assert(checksum);
+ g_assert_cmpstr(checksum, ==, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649"
+ "b934ca495991b7852b855");
+ g_free(checksum);
+ cs = NULL;
+ checksum = NULL;
+}
static void
test_cr_compression_suffix(void)
g_assert_cmpstr(suffix, ==, ".xz");
}
-
static void
test_cr_detect_compression(void)
{
buffer[ret] = '\0';
g_assert_cmpstr(buffer, ==, content);
ret = cr_close(file, &tmp_err);
- g_assert_cmpint(ret, ==, CR_CW_OK);
+ g_assert_cmpint(ret, ==, CRE_OK);
g_assert(!tmp_err);
}
case OUTPUT_TYPE_PUTS:
ret = cr_puts(file, content, &tmp_err);
- g_assert_cmpint(ret, ==, CR_CW_OK);
+ g_assert_cmpint(ret, ==, CRE_OK);
g_assert(!tmp_err);
break;
}
ret = cr_close(file, &tmp_err);
- g_assert_cmpint(ret, ==, CR_CW_OK);
+ g_assert_cmpint(ret, ==, CRE_OK);
g_assert(!tmp_err);
// Read and compare
{
g_test_init(&argc, &argv, NULL);
+ g_test_add_func("/compression_wrapper/test_cr_contentstat",
+ test_cr_contentstat);
g_test_add_func("/compression_wrapper/test_cr_compression_suffix",
test_cr_compression_suffix);
g_test_add_func("/compression_wrapper/test_cr_detect_compression",
projects / services / createrepo_c.git / commitdiff