test/test.c

   1 #define _XOPEN_SOURCE 500
   2 #include <stdlib.h>
   3 #include <stdio.h>
   4 #include <stdint.h>
   5 #include <stdarg.h>
   6 #include <sys/types.h>
   7 #include <sys/stat.h>
   8 #include <fcntl.h>
   9 #include <sys/mman.h>
  10 #include <errno.h>
  11 #include <string.h>
  12 #include <unistd.h>
  13
  14
  15 /* Print formated string into automtically reallocated @uffer.
  16  * @buffer automatically reallocated buffer. Must be &NULL or preallocated
  17  * memory.
  18  * @format format string as for printf(3)
  19  * @ap list of variadic arguments, after call will be in udefined state
  20  * @Returns number of bytes printed. In case of errror, -1 and NULL @buffer */
  21 int test_vasprintf(char **buffer, const char *format, va_list ap) {
  22     va_list aq;
  23     int length, new_length;
  24     char *new_buffer;
  25
  26     if (!buffer || !format) {
  27         if (buffer) {
  28             free(*buffer);
  29             *buffer = NULL;
  30         }
  31         return -1;
  32     }
  33
  34     va_copy(aq, ap);
  35     length = vsnprintf(NULL, 0, format, aq) + 1;
  36     va_end(aq);
  37     if (length <= 0) {
  38         free(*buffer);
  39         *buffer = NULL;
  40         return -1;
  41     }
  42
  43     new_buffer = realloc(*buffer, length);
  44     if (!new_buffer) {
  45         free(*buffer);
  46         *buffer = NULL;
  47         return -1;
  48     }
  49     *buffer = new_buffer;
  50
  51     new_length = vsnprintf(*buffer, length, format, ap);
  52     if (new_length >= length) {
  53         free(*buffer);
  54         *buffer = NULL;
  55         return -1;
  56     }
  57
  58     return new_length;
  59 }
  60
  61
  62 /* Print formated string into automtically reallocated @uffer.
  63  * @buffer automatically reallocated buffer. Must be &NULL or preallocated
  64  * memory.
  65  * @format format string as for printf(3)
  66  * @... variadic arguments
  67  * @Returns number of bytes printed. In case of errror, -1 and NULL @buffer */
  68 int test_asprintf(char **buffer, const char *format, ...) {
  69     int ret;
  70     va_list ap;
  71     va_start(ap, format);
  72     ret = test_vasprintf(buffer, format, ap);
  73     va_end(ap);
  74     return ret;
  75 }
  76
  77
  78 int test_mmap_file(const char *file, int *fd, void **buffer, size_t *length) {
  79     struct stat file_info;
  80
  81     if (!file || !fd || !buffer || !length) return -1;
  82
  83
  84     *fd = open(file, O_RDONLY);
  85     if (*fd == -1) {
  86         fprintf(stderr, "%s: Could not open file: %s\n", file, strerror(errno));
  87         return -1;
  88     }
  89
  90     if (-1 == fstat(*fd, &file_info)) {
  91         fprintf(stderr, "%s: Could not get file size: %s\n", file,
  92                 strerror(errno));
  93         close(*fd);
  94         return -1;
  95     }
  96     if (file_info.st_size < 0) {
  97         fprintf(stderr, "File `%s' has negative size: %jd\n", file,
  98                 (intmax_t) file_info.st_size);
  99         close(*fd);
 100         return -1;
 101     }
 102     *length = file_info.st_size;
 103
 104     *buffer = mmap(NULL, *length, PROT_READ, MAP_PRIVATE, *fd, 0);
 105     if (*buffer == MAP_FAILED) {
 106         fprintf(stderr, "%s: Could not map file to memory: %s\n", file,
 107                 strerror(errno));
 108         close(*fd);
 109         return -1;
 110     }
 111
 112     return 0;
 113 }
 114
 115
 116 int test_munmap_file(int fd, void *buffer, size_t length) {
 117     int err = 0;
 118     long int page_size = sysconf(_SC_PAGE_SIZE);
 119     size_t pages = (length % page_size) ?
 120         ((length / page_size) + 1) * page_size:
 121         length;
 122
 123     err = munmap(buffer, pages);
 124     if (err) {
 125         fprintf(stderr, "Could not unmap memory at %p and length %zu: %s\n",
 126                 buffer, pages, strerror(errno));
 127     }
 128
 129     err = close(fd);
 130     if (err) {
 131         fprintf(stderr, "Could close file descriptor %d: %s\n", fd,
 132                 strerror(errno));
 133     }
 134
 135     return err;
 136 }
 137