use LOG_ERROR as logging shorthand in utils and tests

diff --git a/include/zck.h.in b/include/zck.h.in
index 263c2ea46a1fc9b269c5b5412e0efc39d533b145..0ca5c5fb49c8376274671baabd19fe9c60afd3f9 100644 (file)
--- a/include/zck.h.in
+++ b/include/zck.h.in
@@ -75,12 +75,6 @@ typedef size_t (*zck_wcb)(void *ptr, size_t l, size_t c, void *dl_v);
     #define ZCK_PUBLIC_API __attribute__((visibility("default")))
 #endif
 
-#ifdef _WIN32
-#define ZCK_LOG_ERROR(...) fprintf(stderr, __VA_ARGS__)
-#else
-#define ZCK_LOG_ERROR(...) dprintf(STDERR_FILENO, __VA_ARGS__)
-#endif
-
 /*******************************************************************
  * Reading a zchunk file
  *******************************************************************/

diff --git a/src/unzck.c b/src/unzck.c
index 34a5386abc4a5211c4fff52962a495e4122ffdaa..43de48556a34e41467ce66452d526d757f81d4b7 100644 (file)
--- a/src/unzck.c
+++ b/src/unzck.c
@@ -127,13 +127,13 @@ int main (int argc, char *argv[]) {
     if(!arguments.std_out) {
         if(strlen(arguments.args[0]) < 5 ||
            strcmp(arguments.args[0] + strlen(arguments.args[0]) - 4, ".zck") != 0) {
-            ZCK_LOG_ERROR("Not a *.zck file: %s\n", arguments.args[0]);
+            LOG_ERROR("Not a *.zck file: %s\n", arguments.args[0]);
             exit(1);
         }
     }
     int src_fd = open(arguments.args[0], O_RDONLY | O_BINARY);
     if(src_fd < 0) {
-        ZCK_LOG_ERROR("Unable to open %s\n", arguments.args[0]);
+        LOG_ERROR("Unable to open %s\n", arguments.args[0]);
         perror("");
         exit(1);
     }
@@ -156,7 +156,7 @@ int main (int argc, char *argv[]) {
     if(!arguments.std_out) {
         dst_fd = open(out_name, O_TRUNC | O_WRONLY | O_CREAT | O_BINARY, 0666);
         if(dst_fd < 0) {
-            ZCK_LOG_ERROR("Unable to open %s", out_name);
+            LOG_ERROR("Unable to open %s", out_name);
             perror("");
             free(out_name);
             exit(1);
@@ -168,7 +168,7 @@ int main (int argc, char *argv[]) {
     char *data = NULL;
     zckCtx *zck = zck_create();
     if(!zck_init_read(zck, src_fd)) {
-        ZCK_LOG_ERROR("%s", zck_get_error(zck));
+        LOG_ERROR("%s", zck_get_error(zck));
         goto error2;
     }
 
@@ -177,7 +177,7 @@ int main (int argc, char *argv[]) {
         zckChunk *dict = zck_get_first_chunk(zck);
         ssize_t dict_size = zck_get_chunk_size(dict);
         if(dict_size < 0) {
-            ZCK_LOG_ERROR("%s", zck_get_error(zck));
+            LOG_ERROR("%s", zck_get_error(zck));
             goto error2;
         }
         data = calloc(dict_size, 1);
@@ -185,24 +185,24 @@ int main (int argc, char *argv[]) {
         ssize_t read_size = zck_get_chunk_data(dict, data, dict_size);
         if(read_size != dict_size) {
             if(read_size < 0)
-                ZCK_LOG_ERROR("%s", zck_get_error(zck));
+                LOG_ERROR("%s", zck_get_error(zck));
             else
-                ZCK_LOG_ERROR(
+                LOG_ERROR(
                         "Dict size doesn't match expected size: %li != %li\n",
                         read_size, dict_size);
             goto error2;
         }
         if(write(dst_fd, data, dict_size) != dict_size) {
-            ZCK_LOG_ERROR("Error writing to %s\n", out_name);
+            LOG_ERROR("Error writing to %s\n", out_name);
             goto error2;
         }
         if(dict_size > 0) {
             int ret = zck_get_chunk_valid(dict);
             if(ret < 1) {
                 if(ret == -1)
-                    ZCK_LOG_ERROR("Data checksum failed verification\n");
+                    LOG_ERROR("Data checksum failed verification\n");
                 else
-                    ZCK_LOG_ERROR("%s", zck_get_error(zck));
+                    LOG_ERROR("%s", zck_get_error(zck));
                 goto error2;
             }
         }
@@ -212,7 +212,7 @@ int main (int argc, char *argv[]) {
     int ret = zck_validate_data_checksum(zck);
     if(ret < 1) {
         if(ret == -1)
-            ZCK_LOG_ERROR("Data checksum failed verification\n");
+            LOG_ERROR("Data checksum failed verification\n");
         goto error2;
     }
 
@@ -222,23 +222,23 @@ int main (int argc, char *argv[]) {
     while(true) {
         ssize_t read = zck_read(zck, data, BUF_SIZE);
         if(read < 0) {
-            ZCK_LOG_ERROR("%s", zck_get_error(zck));
+            LOG_ERROR("%s", zck_get_error(zck));
             goto error2;
         }
         if(read == 0)
             break;
         if(write(dst_fd, data, read) != read) {
-            ZCK_LOG_ERROR("Error writing to %s\n", out_name);
+            LOG_ERROR("Error writing to %s\n", out_name);
             goto error2;
         }
         total += read;
     }
     if(!zck_close(zck)) {
-        ZCK_LOG_ERROR("%s", zck_get_error(zck));
+        LOG_ERROR("%s", zck_get_error(zck));
         goto error2;
     }
     if(arguments.log_level <= ZCK_LOG_INFO)
-        ZCK_LOG_ERROR("Decompressed %lu bytes\n", (unsigned long)total);
+        LOG_ERROR("Decompressed %lu bytes\n", (unsigned long)total);
     good_exit = true;
 error2:
     free(data);

diff --git a/src/util_common.h b/src/util_common.h
index 1aad13cb899f1309f7f63802926ff1fa9402d314..9a925e10219594855dfe2eae05c80220d5de4e54 100644 (file)
--- a/src/util_common.h
+++ b/src/util_common.h
@@ -19,4 +19,10 @@ void version();
 char* basename(char*);
 #endif
 
+#ifdef _WIN32
+#define LOG_ERROR(...) fprintf(stderr, __VA_ARGS__)
+#else
+#define LOG_ERROR(...) dprintf(STDERR_FILENO, __VA_ARGS__)
+#endif
+
 #endif

diff --git a/src/zck.c b/src/zck.c
index e3ae55b94c98e351116a48e26acab969c23f8bb6..151e208c4a2962519538527d781fcd32b4eb6e4b 100644 (file)
--- a/src/zck.c
+++ b/src/zck.c
@@ -108,7 +108,7 @@ static error_t parse_opt (int key, char *arg, struct argp_state *state) {
             else if (!strcmp(arg, "sha512_128"))
                 arguments->chunk_hashtype = ZCK_HASH_SHA512_128;
             else {
-                ZCK_LOG_ERROR("Wrong value for chunk hashtype. \n "
+                LOG_ERROR("Wrong value for chunk hashtype. \n "
                         "It should be one of sha1|sha256|sha512|sha512_128 instead of %s\n", arg);
                 return -EINVAL;
             }
@@ -190,7 +190,7 @@ int main (int argc, char *argv[]) {
     if(arguments.dict != NULL) {
         int dict_fd = open(arguments.dict, O_RDONLY | O_BINARY);
         if(dict_fd < 0) {
-            ZCK_LOG_ERROR("Unable to open dictionary %s for reading",
+            LOG_ERROR("Unable to open dictionary %s for reading",
                           arguments.dict);
             perror("");
             exit(1);
@@ -216,7 +216,7 @@ int main (int argc, char *argv[]) {
 
     int dst_fd = open(out_name, O_TRUNC | O_WRONLY | O_CREAT | O_BINARY, 0666);
     if(dst_fd < 0) {
-        ZCK_LOG_ERROR("Unable to open %s", out_name);
+        LOG_ERROR("Unable to open %s", out_name);
         perror("");
         if(dict) {
             free(dict);
@@ -228,12 +228,12 @@ int main (int argc, char *argv[]) {
 
     zckCtx *zck = zck_create();
     if(zck == NULL) {
-        ZCK_LOG_ERROR("%s", zck_get_error(NULL));
+        LOG_ERROR("%s", zck_get_error(NULL));
         zck_clear_error(NULL);
         exit(1);
     }
     if(!zck_init_write(zck, dst_fd)) {
-        ZCK_LOG_ERROR("Unable to write to %s: %s", out_name,
+        LOG_ERROR("Unable to write to %s: %s", out_name,
                 zck_get_error(zck));
         exit(1);
     }
@@ -242,41 +242,41 @@ int main (int argc, char *argv[]) {
     if(arguments.compression_format) {
         if(strncmp(arguments.compression_format, "zstd", 4) == 0) {
             if(!zck_set_ioption(zck, ZCK_COMP_TYPE, ZCK_COMP_ZSTD)) {
-                ZCK_LOG_ERROR("%s\n", zck_get_error(zck));
+                LOG_ERROR("%s\n", zck_get_error(zck));
                 exit(1);
             }
         } else if(strncmp(arguments.compression_format, "none", 4) == 0) {
             if(!zck_set_ioption(zck, ZCK_COMP_TYPE, ZCK_COMP_NONE)) {
-                ZCK_LOG_ERROR("%s\n", zck_get_error(zck));
+                LOG_ERROR("%s\n", zck_get_error(zck));
                 exit(1);
             }
         } else {
-            ZCK_LOG_ERROR("Unknown compression type: %s\n", arguments.compression_format);
+            LOG_ERROR("Unknown compression type: %s\n", arguments.compression_format);
             exit(1);
         }
     }
     if(dict_size > 0) {
         if(!zck_set_soption(zck, ZCK_COMP_DICT, dict, dict_size)) {
-            ZCK_LOG_ERROR("%s\n", zck_get_error(zck));
+            LOG_ERROR("%s\n", zck_get_error(zck));
             exit(1);
         }
     }
     free(dict);
     if(arguments.manual_chunk) {
         if(!zck_set_ioption(zck, ZCK_MANUAL_CHUNK, 1)) {
-            ZCK_LOG_ERROR("%s\n", zck_get_error(zck));
+            LOG_ERROR("%s\n", zck_get_error(zck));
             exit(1);
         }
     }
     if(arguments.uncompressed) {
         if(!zck_set_ioption(zck, ZCK_UNCOMP_HEADER, 1)) {
-            ZCK_LOG_ERROR("%s\n", zck_get_error(zck));
+            LOG_ERROR("%s\n", zck_get_error(zck));
             exit(1);
         }
     }
     if (arguments.chunk_hashtype != ZCK_HASH_UNKNOWN) {
         if(!zck_set_ioption(zck, ZCK_HASH_CHUNK_TYPE, arguments.chunk_hashtype)) {
-            ZCK_LOG_ERROR("Unable to set hash type %s\n", zck_get_error(zck));
+            LOG_ERROR("Unable to set hash type %s\n", zck_get_error(zck));
             exit(1);
         }
     }
@@ -284,14 +284,14 @@ int main (int argc, char *argv[]) {
     int in_fd = open(arguments.args[0], O_RDONLY | O_BINARY);
     off_t in_size = 0;
     if(in_fd < 0) {
-        ZCK_LOG_ERROR("Unable to open %s for reading",
+        LOG_ERROR("Unable to open %s for reading",
                 arguments.args[0]);
         perror("");
         exit(1);
     }
     in_size = lseek(in_fd, 0, SEEK_END);
     if(in_size < 0) {
-        ZCK_LOG_ERROR("Unable to seek to end of input file");
+        LOG_ERROR("Unable to seek to end of input file");
         exit(1);
     }
     if(lseek(in_fd, 0, SEEK_SET) < 0) {
@@ -302,7 +302,7 @@ int main (int argc, char *argv[]) {
         data = malloc(in_size);
         assert(data);
         if(read(in_fd, data, in_size) < in_size) {
-            ZCK_LOG_ERROR("Unable to read from input file\n");
+            LOG_ERROR("Unable to read from input file\n");
             exit(1);
         }
         close(in_fd);
@@ -334,7 +334,7 @@ int main (int argc, char *argv[]) {
         /* Buzhash rolling window */
         } else {
             if(zck_write(zck, data, in_size) < 0) {
-                ZCK_LOG_ERROR("%s", zck_get_error(zck));
+                LOG_ERROR("%s", zck_get_error(zck));
                 exit(1);
             }
         }
@@ -345,7 +345,7 @@ int main (int argc, char *argv[]) {
         exit(1);
     }
     if(arguments.log_level <= ZCK_LOG_INFO) {
-        ZCK_LOG_ERROR("Wrote %lu bytes in %lu chunks\n",
+        LOG_ERROR("Wrote %lu bytes in %lu chunks\n",
                 (unsigned long)(zck_get_data_length(zck) +
                                 zck_get_header_length(zck)),
                 (long)zck_get_chunk_count(zck));

diff --git a/src/zck_delta_size.c b/src/zck_delta_size.c
index 8fdc5388de384f130fbecde1e2c155a76aaa72cd..a52b4b790f8d54d49ba8523d4b4a10b71e6f21de 100644 (file)
--- a/src/zck_delta_size.c
+++ b/src/zck_delta_size.c
@@ -111,18 +111,18 @@ int main (int argc, char *argv[]) {
 
     int src_fd = open(arguments.args[0], O_RDONLY | O_BINARY);
     if(src_fd < 0) {
-        ZCK_LOG_ERROR("Unable to open %s\n", arguments.args[0]);
+        LOG_ERROR("Unable to open %s\n", arguments.args[0]);
         perror("");
         exit(1);
     }
     zckCtx *zck_src = zck_create();
     if(zck_src == NULL) {
-        ZCK_LOG_ERROR("%s", zck_get_error(NULL));
+        LOG_ERROR("%s", zck_get_error(NULL));
         zck_clear_error(NULL);
         exit(1);
     }
     if(!zck_init_read(zck_src, src_fd)) {
-        ZCK_LOG_ERROR("Error reading %s: %s", arguments.args[0],
+        LOG_ERROR("Error reading %s: %s", arguments.args[0],
                 zck_get_error(zck_src));
         zck_free(&zck_src);
         exit(1);
@@ -131,20 +131,20 @@ int main (int argc, char *argv[]) {
 
     int tgt_fd = open(arguments.args[1], O_RDONLY | O_BINARY);
     if(tgt_fd < 0) {
-        ZCK_LOG_ERROR("Unable to open %s\n", arguments.args[1]);
+        LOG_ERROR("Unable to open %s\n", arguments.args[1]);
         perror("");
         zck_free(&zck_src);
         exit(1);
     }
     zckCtx *zck_tgt = zck_create();
     if(zck_tgt == NULL) {
-        ZCK_LOG_ERROR("%s", zck_get_error(NULL));
+        LOG_ERROR("%s", zck_get_error(NULL));
         zck_clear_error(NULL);
         zck_free(&zck_src);
         exit(1);
     }
     if(!zck_init_read(zck_tgt, tgt_fd)) {
-        ZCK_LOG_ERROR("Error reading %s: %s", arguments.args[1],
+        LOG_ERROR("Error reading %s: %s", arguments.args[1],
                 zck_get_error(zck_tgt));
         zck_free(&zck_src);
         zck_free(&zck_tgt);
@@ -153,10 +153,10 @@ int main (int argc, char *argv[]) {
     close(tgt_fd);
 
     if(zck_get_chunk_hash_type(zck_tgt) != zck_get_chunk_hash_type(zck_src)) {
-        ZCK_LOG_ERROR("ERROR: Chunk hash types don't match:\n");
-        ZCK_LOG_ERROR("   %s: %s\n", arguments.args[0],
+        LOG_ERROR("ERROR: Chunk hash types don't match:\n");
+        LOG_ERROR("   %s: %s\n", arguments.args[0],
                 zck_hash_name_from_type(zck_get_chunk_hash_type(zck_tgt)));
-        ZCK_LOG_ERROR("   %s: %s\n", arguments.args[1],
+        LOG_ERROR("   %s: %s\n", arguments.args[1],
                 zck_hash_name_from_type(zck_get_chunk_hash_type(zck_src)));
         zck_free(&zck_src);
         zck_free(&zck_tgt);
@@ -168,7 +168,7 @@ int main (int argc, char *argv[]) {
         exit(1);
 
     if(!zck_compare_chunk_digest(tgt_idx, src_idx))
-        ZCK_LOG_ERROR("WARNING: Dicts don't match\n");
+        LOG_ERROR("WARNING: Dicts don't match\n");
     ssize_t dl_size = zck_get_header_length(zck_tgt);
     if(dl_size < 0)
         exit(1);

diff --git a/src/zck_dl.c b/src/zck_dl.c
index 8fdc5388de384f130fbecde1e2c155a76aaa72cd..a52b4b790f8d54d49ba8523d4b4a10b71e6f21de 100644 (file)
--- a/src/zck_dl.c
+++ b/src/zck_dl.c
@@ -111,18 +111,18 @@ int main (int argc, char *argv[]) {
 
     int src_fd = open(arguments.args[0], O_RDONLY | O_BINARY);
     if(src_fd < 0) {
-        ZCK_LOG_ERROR("Unable to open %s\n", arguments.args[0]);
+        LOG_ERROR("Unable to open %s\n", arguments.args[0]);
         perror("");
         exit(1);
     }
     zckCtx *zck_src = zck_create();
     if(zck_src == NULL) {
-        ZCK_LOG_ERROR("%s", zck_get_error(NULL));
+        LOG_ERROR("%s", zck_get_error(NULL));
         zck_clear_error(NULL);
         exit(1);
     }
     if(!zck_init_read(zck_src, src_fd)) {
-        ZCK_LOG_ERROR("Error reading %s: %s", arguments.args[0],
+        LOG_ERROR("Error reading %s: %s", arguments.args[0],
                 zck_get_error(zck_src));
         zck_free(&zck_src);
         exit(1);
@@ -131,20 +131,20 @@ int main (int argc, char *argv[]) {
 
     int tgt_fd = open(arguments.args[1], O_RDONLY | O_BINARY);
     if(tgt_fd < 0) {
-        ZCK_LOG_ERROR("Unable to open %s\n", arguments.args[1]);
+        LOG_ERROR("Unable to open %s\n", arguments.args[1]);
         perror("");
         zck_free(&zck_src);
         exit(1);
     }
     zckCtx *zck_tgt = zck_create();
     if(zck_tgt == NULL) {
-        ZCK_LOG_ERROR("%s", zck_get_error(NULL));
+        LOG_ERROR("%s", zck_get_error(NULL));
         zck_clear_error(NULL);
         zck_free(&zck_src);
         exit(1);
     }
     if(!zck_init_read(zck_tgt, tgt_fd)) {
-        ZCK_LOG_ERROR("Error reading %s: %s", arguments.args[1],
+        LOG_ERROR("Error reading %s: %s", arguments.args[1],
                 zck_get_error(zck_tgt));
         zck_free(&zck_src);
         zck_free(&zck_tgt);
@@ -153,10 +153,10 @@ int main (int argc, char *argv[]) {
     close(tgt_fd);
 
     if(zck_get_chunk_hash_type(zck_tgt) != zck_get_chunk_hash_type(zck_src)) {
-        ZCK_LOG_ERROR("ERROR: Chunk hash types don't match:\n");
-        ZCK_LOG_ERROR("   %s: %s\n", arguments.args[0],
+        LOG_ERROR("ERROR: Chunk hash types don't match:\n");
+        LOG_ERROR("   %s: %s\n", arguments.args[0],
                 zck_hash_name_from_type(zck_get_chunk_hash_type(zck_tgt)));
-        ZCK_LOG_ERROR("   %s: %s\n", arguments.args[1],
+        LOG_ERROR("   %s: %s\n", arguments.args[1],
                 zck_hash_name_from_type(zck_get_chunk_hash_type(zck_src)));
         zck_free(&zck_src);
         zck_free(&zck_tgt);
@@ -168,7 +168,7 @@ int main (int argc, char *argv[]) {
         exit(1);
 
     if(!zck_compare_chunk_digest(tgt_idx, src_idx))
-        ZCK_LOG_ERROR("WARNING: Dicts don't match\n");
+        LOG_ERROR("WARNING: Dicts don't match\n");
     ssize_t dl_size = zck_get_header_length(zck_tgt);
     if(dl_size < 0)
         exit(1);

diff --git a/src/zck_gen_zdict.c b/src/zck_gen_zdict.c
index a20ee3dcf2cd1dfceba7b7487a317f8e3c2dd975..76d284c87c959f224243dffed40b6fa5fb1a62b1 100644 (file)
--- a/src/zck_gen_zdict.c
+++ b/src/zck_gen_zdict.c
@@ -144,24 +144,24 @@ char *get_tmp_dir(char *old_dir) {
         // Get the current working directory:
         if ((prev_cwd = _getcwd( NULL, 0 )) == NULL)
         {
-            ZCK_LOG_ERROR("Could not find current workdir");
+            LOG_ERROR("Could not find current workdir");
             return NULL;
         }
         if (chdir(tmpdir) != 0)
         {
-            ZCK_LOG_ERROR("Could not change to Temp Dir");
+            LOG_ERROR("Could not change to Temp Dir");
             return NULL;
         }
         printf("generating temp name: ... \n");
         errno_t err = _mktemp_s(template, 14);
         if (err)
         {
-            ZCK_LOG_ERROR("Could not generate temporary name");
+            LOG_ERROR("Could not generate temporary name");
             return NULL;
         }
         if (_mkdir(template) != 0)
         {
-            ZCK_LOG_ERROR("Could not create temp folder");
+            LOG_ERROR("Could not create temp folder");
             return NULL;
         }
         assert(chdir(template) == 0);
@@ -212,7 +212,7 @@ int main (int argc, char *argv[]) {
 
     int src_fd = open(arguments.args[0], O_RDONLY | O_BINARY);
     if(src_fd < 0) {
-        ZCK_LOG_ERROR("Unable to open %s\n", arguments.args[0]);
+        LOG_ERROR("Unable to open %s\n", arguments.args[0]);
         perror("");
         exit(1);
     }
@@ -232,14 +232,14 @@ int main (int argc, char *argv[]) {
     char *data = NULL;
     zckCtx *zck = zck_create();
     if(!zck_init_read(zck, src_fd)) {
-        ZCK_LOG_ERROR("%s", zck_get_error(zck));
+        LOG_ERROR("%s", zck_get_error(zck));
         goto error2;
     }
 
     int ret = zck_validate_data_checksum(zck);
     if(ret < 1) {
         if(ret == -1)
-            ZCK_LOG_ERROR("Data checksum failed verification\n");
+            LOG_ERROR("Data checksum failed verification\n");
         goto error2;
     }
 
@@ -250,7 +250,7 @@ int main (int argc, char *argv[]) {
             continue;
         ssize_t chunk_size = zck_get_chunk_size(idx);
         if(chunk_size < 0) {
-            ZCK_LOG_ERROR("%s", zck_get_error(zck));
+            LOG_ERROR("%s", zck_get_error(zck));
             goto error2;
         }
         data = calloc(chunk_size, 1);
@@ -258,9 +258,9 @@ int main (int argc, char *argv[]) {
         ssize_t read_size = zck_get_chunk_data(idx, data, chunk_size);
         if(read_size != chunk_size) {
             if(read_size < 0)
-                ZCK_LOG_ERROR("%s", zck_get_error(zck));
+                LOG_ERROR("%s", zck_get_error(zck));
             else
-                ZCK_LOG_ERROR(
+                LOG_ERROR(
                         "Chunk %li size doesn't match expected size: %li != %li\n",
                         zck_get_chunk_number(idx), read_size, chunk_size);
             goto error2;
@@ -272,13 +272,13 @@ int main (int argc, char *argv[]) {
                  dir, out_name, zck_get_chunk_number(idx));
         int dst_fd = open(dict_block, O_TRUNC | O_WRONLY | O_CREAT | O_BINARY, 0666);
         if(dst_fd < 0) {
-            ZCK_LOG_ERROR("Unable to open %s", dict_block);
+            LOG_ERROR("Unable to open %s", dict_block);
             perror("");
             free(dict_block);
             goto error2;
         }
         if(write(dst_fd, data, chunk_size) != chunk_size) {
-            ZCK_LOG_ERROR("Error writing to %s\n", dict_block);
+            LOG_ERROR("Error writing to %s\n", dict_block);
             free(dict_block);
             goto error2;
         }
@@ -289,7 +289,7 @@ int main (int argc, char *argv[]) {
     snprintf(out_name + strlen(base_name) - 4, 7, ".zdict");
 
     if(!zck_close(zck)) {
-        ZCK_LOG_ERROR("%s", zck_get_error(zck));
+        LOG_ERROR("%s", zck_get_error(zck));
         goto error2;
     }
 
@@ -300,26 +300,26 @@ int main (int argc, char *argv[]) {
     int w = system(buf);
     if (w < 0)
     {
-        ZCK_LOG_ERROR("Error generating dict\n");
+        LOG_ERROR("Error generating dict\n");
         goto error2;
     }
 #else
     int pid = fork();
     if(pid == 0) {
         execl("/usr/bin/zstd", "zstd", "--train", dir, "-r", "-o", out_name, NULL);
-        ZCK_LOG_ERROR("Unable to find /usr/bin/zstd\n");
+        LOG_ERROR("Unable to find /usr/bin/zstd\n");
         exit(1);
     }
     int wstatus = 0;
     int w = waitpid(pid, &wstatus, 0);
 
     if (w == -1) {
-        ZCK_LOG_ERROR("Error waiting for zstd\n");
+        LOG_ERROR("Error waiting for zstd\n");
         perror("");
         goto error2;
     }
     if(WEXITSTATUS(wstatus) != 0) {
-        ZCK_LOG_ERROR("Error generating dict\n");
+        LOG_ERROR("Error generating dict\n");
         goto error2;
     }
 #endif
@@ -329,7 +329,7 @@ int main (int argc, char *argv[]) {
         DIR *dfd;
 
         if ((dfd = opendir(dir)) == NULL) {
-            ZCK_LOG_ERROR("Unable to read %s\n", dir);
+            LOG_ERROR("Unable to read %s\n", dir);
             goto error2;
         }
 
@@ -341,23 +341,23 @@ int main (int argc, char *argv[]) {
             snprintf(full_path, strlen(dir) + strlen(dp->d_name) + 2, "%s/%s",
                      dir, dp->d_name);
             if(unlink(full_path) != 0) {
-                ZCK_LOG_ERROR("Unable to remove %s\n", full_path);
+                LOG_ERROR("Unable to remove %s\n", full_path);
                 perror("");
                 err = true;
             } else {
                 if(arguments.log_level <= ZCK_LOG_INFO)
-                    ZCK_LOG_ERROR("Removed %s\n", full_path);
+                    LOG_ERROR("Removed %s\n", full_path);
             }
             free(full_path);
         }
         closedir(dfd);
         if(!err) {
             if(rmdir(dir) != 0) {
-                ZCK_LOG_ERROR("Unable to remove %s\n", dir);
+                LOG_ERROR("Unable to remove %s\n", dir);
                 perror("");
             }
         } else {
-            ZCK_LOG_ERROR("Errors encountered, not removing %s\n",
+            LOG_ERROR("Errors encountered, not removing %s\n",
                     dir);
         }
     }

diff --git a/src/zck_read_header.c b/src/zck_read_header.c
index 5c6acbbb8adb13e2999a6b151c8a93526655d6ba..7f69fc4f04e5fe8cb883346542a433dff54bb0dd 100644 (file)
--- a/src/zck_read_header.c
+++ b/src/zck_read_header.c
@@ -133,12 +133,12 @@ int main (int argc, char *argv[]) {
 
     zckCtx *zck = zck_create();
     if(zck == NULL) {
-        ZCK_LOG_ERROR("%s", zck_get_error(NULL));
+        LOG_ERROR("%s", zck_get_error(NULL));
         zck_clear_error(NULL);
         exit(1);
     }
     if(!zck_init_read(zck, src_fd)) {
-        ZCK_LOG_ERROR("Error reading zchunk header: %s",
+        LOG_ERROR("Error reading zchunk header: %s",
                 zck_get_error(zck));
         zck_free(&zck);
         exit(1);
@@ -173,7 +173,7 @@ int main (int argc, char *argv[]) {
             chk=zck_get_next_chunk(chk)) {
             char *digest = zck_get_chunk_digest(chk);
             if(digest == NULL) {
-                ZCK_LOG_ERROR("%s", zck_get_error(zck));
+                LOG_ERROR("%s", zck_get_error(zck));
                 exit(1);
             }
             char *digest_uncompressed = zck_get_chunk_digest_uncompressed(chk);

diff --git a/test/lib/util.h b/test/lib/util.h
index e291237bc0671b66e02852d9223730b65c9276d0..d3d9fe251390480c4bb972a18d950dc926411452 100644 (file)
--- a/test/lib/util.h
+++ b/test/lib/util.h
@@ -35,6 +35,12 @@
 #define O_BINARY 0
 #endif
 
+#ifdef _WIN32
+#define LOG_ERROR(...) fprintf(stderr, __VA_ARGS__)
+#else
+#define LOG_ERROR(...) dprintf(STDERR_FILENO, __VA_ARGS__)
+#endif
+
 char *get_hash(char *data, size_t length, int type)
     ZCK_WARN_UNUSED;
 

diff --git a/test/zck_cmp_uncomp.c b/test/zck_cmp_uncomp.c
index 38dceed827e411ca4a1bc7683696a3eee0d0b615..2858a0e03504bd85dd86ee14df7554b06fc6c9c7 100644 (file)
--- a/test/zck_cmp_uncomp.c
+++ b/test/zck_cmp_uncomp.c
@@ -122,7 +122,7 @@ int main (int argc, char *argv[]) {
         exit(retval);
 
     if (argc < 1) {
-        ZCK_LOG_ERROR("Usage : %s filename", argv[0]);
+        LOG_ERROR("Usage : %s filename", argv[0]);
         exit(1);
     }
 
@@ -132,12 +132,12 @@ int main (int argc, char *argv[]) {
     zckCtx *zckSrc = zck_create();
     zckCtx *zckDst = zck_create();
     if(!zckSrc || !zckDst) {
-        ZCK_LOG_ERROR("%s", zck_get_error(NULL));
+        LOG_ERROR("%s", zck_get_error(NULL));
         zck_clear_error(NULL);
         exit(1);
     }
     if(!zck_init_write(zckSrc, dst_fd)) {
-        ZCK_LOG_ERROR("Unable to write %s ",
+        LOG_ERROR("Unable to write %s ",
                 zck_get_error(zckSrc));
         exit(1);
     }
@@ -145,7 +145,7 @@ int main (int argc, char *argv[]) {
     int in_fd = open(arguments.args[0], O_RDONLY | O_BINARY);
     off_t in_size = 0;
     if(in_fd < 0) {
-        ZCK_LOG_ERROR("Unable to open %s for reading",
+        LOG_ERROR("Unable to open %s for reading",
                 arguments.args[0]);
         perror("");
         exit(1);
@@ -156,14 +156,14 @@ int main (int argc, char *argv[]) {
      */
     int zck_fd = open(arguments.args[1], O_RDONLY | O_BINARY);
     if(zck_fd < 0) {
-        ZCK_LOG_ERROR("Unable to open %s for reading",
+        LOG_ERROR("Unable to open %s for reading",
                 arguments.args[1]);
         perror("");
         exit(1);
     }
 
     if(!zck_init_read(zckDst, zck_fd)) {
-        ZCK_LOG_ERROR("Error reading zchunk header: %s",
+        LOG_ERROR("Error reading zchunk header: %s",
                 zck_get_error(zckDst));
         zck_free(&zckSrc);
         zck_free(&zckDst);
@@ -172,7 +172,7 @@ int main (int argc, char *argv[]) {
 
     in_size = lseek(in_fd, 0, SEEK_END);
     if(in_size < 0) {
-        ZCK_LOG_ERROR("Unable to seek to end of input file");
+        LOG_ERROR("Unable to seek to end of input file");
         exit(1);
     }
     if(lseek(in_fd, 0, SEEK_SET) < 0) {
@@ -181,25 +181,25 @@ int main (int argc, char *argv[]) {
     }
 
     if(!zck_set_ioption(zckSrc, ZCK_UNCOMP_HEADER, 1)) {
-        ZCK_LOG_ERROR("%s\n", zck_get_error(zckSrc));
+        LOG_ERROR("%s\n", zck_get_error(zckSrc));
         exit(1);
     }
     if(!zck_set_ioption(zckSrc, ZCK_COMP_TYPE, ZCK_COMP_NONE))
         exit(1);
     if(!zck_set_ioption(zckSrc, ZCK_HASH_CHUNK_TYPE, ZCK_HASH_SHA256)) {
-        ZCK_LOG_ERROR("Unable to set hash type %s\n", zck_get_error(zckSrc));
+        LOG_ERROR("Unable to set hash type %s\n", zck_get_error(zckSrc));
         exit(1);
     }
 
     char *buf = malloc(BUFSIZE);
     if (!buf) {
-        ZCK_LOG_ERROR("Unable to allocate buffer\n");
+        LOG_ERROR("Unable to allocate buffer\n");
         exit(1);
     }
     ssize_t n;
     while ((n = read(in_fd, buf, BUFSIZE)) > 0) {
         if (zck_write(zckSrc, buf, n) < 0) {
-            ZCK_LOG_ERROR("zck_write failed: %s\n", zck_get_error(zckSrc));
+            LOG_ERROR("zck_write failed: %s\n", zck_get_error(zckSrc));
             exit(1);
         }
     }