test/test.c

   1 #define _XOPEN_SOURCE 500
   2 #include <stdlib.h>
   3 #include <stdio.h>
   4 #include <stdint.h>
   5 #include <inttypes.h>
   6 #include <stdarg.h>
   7 #include <sys/types.h>
   8 #include <sys/stat.h>
   9 #include <fcntl.h>
  10
  11 #ifndef _WIN32
  12 #include <sys/mman.h>
  13 #endif
  14
  15 #include <errno.h>
  16 #include <string.h>
  17 #include <unistd.h>
  18
  19
  20 /* Print formated string into automtically reallocated @uffer.
  21  * @buffer automatically reallocated buffer. Must be &NULL or preallocated
  22  * memory.
  23  * @format format string as for printf(3)
  24  * @ap list of variadic arguments, after call will be in udefined state
  25  * @Returns number of bytes printed. In case of errror, -1 and NULL @buffer */
  26 int test_vasprintf(char **buffer, const char *format, va_list ap) {
  27     va_list aq;
  28     int length, new_length;
  29     char *new_buffer;
  30
  31     if (!buffer || !format) {
  32         if (buffer) {
  33             free(*buffer);
  34             *buffer = NULL;
  35         }
  36         return -1;
  37     }
  38
  39     va_copy(aq, ap);
  40     length = vsnprintf(NULL, 0, format, aq) + 1;
  41     va_end(aq);
  42     if (length <= 0) {
  43         free(*buffer);
  44         *buffer = NULL;
  45         return -1;
  46     }
  47
  48     new_buffer = realloc(*buffer, length);
  49     if (!new_buffer) {
  50         free(*buffer);
  51         *buffer = NULL;
  52         return -1;
  53     }
  54     *buffer = new_buffer;
  55
  56     new_length = vsnprintf(*buffer, length, format, ap);
  57     if (new_length >= length) {
  58         free(*buffer);
  59         *buffer = NULL;
  60         return -1;
  61     }
  62
  63     return new_length;
  64 }
  65
  66
  67 /* Print formated string into automtically reallocated @uffer.
  68  * @buffer automatically reallocated buffer. Must be &NULL or preallocated
  69  * memory.
  70  * @format format string as for printf(3)
  71  * @... variadic arguments
  72  * @Returns number of bytes printed. In case of errror, -1 and NULL @buffer */
  73 int test_asprintf(char **buffer, const char *format, ...) {
  74     int ret;
  75     va_list ap;
  76     va_start(ap, format);
  77     ret = test_vasprintf(buffer, format, ap);
  78     va_end(ap);
  79     return ret;
  80 }
  81
  82
  83 #ifdef _WIN32
  84 int test_mmap_file(const char *file, int *fd, void **buffer, size_t *length) {
  85     struct stat file_info;
  86     int ret, pos = 0;
  87
  88     if (!file || !fd || !buffer || !length) return -1;
  89
  90     *fd = open(file, O_RDONLY);
  91     if (*fd == -1) {
  92         fprintf(stderr, "%s: Could not open file: %s\n", file, strerror(errno));
  93         return -1;
  94     }
  95
  96     if (-1 == fstat(*fd, &file_info)) {
  97         fprintf(stderr, "%s: Could not get file size: %s\n", file,
  98                 strerror(errno));
  99         close(*fd);
 100         return -1;
 101     }
 102     if (file_info.st_size < 0) {
 103         fprintf(stderr, "File `%s' has negative size: %" PRIdMAX "\n", file,
 104                 (intmax_t) file_info.st_size);
 105         close(*fd);
 106         return -1;
 107     }
 108     *length = file_info.st_size;
 109     *buffer = malloc(*length);
 110
 111     if (!*buffer) {
 112         fprintf(stderr, "%s: Could not allocate memory for file mapping: %s\n",
 113                 file, strerror(errno));
 114         close(*fd);
 115         return -1;
 116     }
 117
 118     do {
 119         ret = read(*fd, *buffer + pos, *length - pos);
 120
 121         if (ret > 0) {
 122             pos += ret;
 123         }
 124     } while ((ret < 0 && errno == EINTR) || (ret > 0 && pos < *length));
 125
 126     if (ret < 0) {
 127         fprintf(stderr, "%s: Could not map file to memory: %s\n", file,
 128                 strerror(errno));
 129         free(*buffer);
 130         *buffer = NULL;
 131         close(*fd);
 132         return -1;
 133     }
 134
 135     return 0;
 136 }
 137
 138 int test_munmap_file(int fd, void *buffer, size_t length) {
 139     int err = 0;
 140     free(buffer);
 141
 142     err = close(fd);
 143     if (err) {
 144         fprintf(stderr, "Could close file descriptor %d: %s\n", fd,
 145                 strerror(errno));
 146     }
 147
 148     return err;
 149 }
 150 #else
 151 int test_mmap_file(const char *file, int *fd, void **buffer, size_t *length) {
 152     struct stat file_info;
 153
 154     if (!file || !fd || !buffer || !length) return -1;
 155
 156
 157     *fd = open(file, O_RDONLY);
 158     if (*fd == -1) {
 159         fprintf(stderr, "%s: Could not open file: %s\n", file, strerror(errno));
 160         return -1;
 161     }
 162
 163     if (-1 == fstat(*fd, &file_info)) {
 164         fprintf(stderr, "%s: Could not get file size: %s\n", file,
 165                 strerror(errno));
 166         close(*fd);
 167         return -1;
 168     }
 169     if (file_info.st_size < 0) {
 170         fprintf(stderr, "File `%s' has negative size: %" PRIdMAX "\n", file,
 171                 (intmax_t) file_info.st_size);
 172         close(*fd);
 173         return -1;
 174     }
 175     *length = file_info.st_size;
 176
 177     *buffer = mmap(NULL, *length, PROT_READ, MAP_PRIVATE, *fd, 0);
 178     if (*buffer == MAP_FAILED) {
 179         fprintf(stderr, "%s: Could not map file to memory: %s\n", file,
 180                 strerror(errno));
 181         close(*fd);
 182         return -1;
 183     }
 184
 185     return 0;
 186 }
 187
 188
 189 int test_munmap_file(int fd, void *buffer, size_t length) {
 190     int err = 0;
 191     long int page_size = sysconf(_SC_PAGE_SIZE);
 192     size_t pages = (length % page_size) ?
 193         ((length / page_size) + 1) * page_size:
 194         length;
 195
 196     err = munmap(buffer, pages);
 197     if (err) {
 198         fprintf(stderr, "Could not unmap memory at %p and length %zu: %s\n",
 199                 buffer, pages, strerror(errno));
 200     }
 201
 202     err = close(fd);
 203     if (err) {
 204         fprintf(stderr, "Could close file descriptor %d: %s\n", fd,
 205                 strerror(errno));
 206     }
 207
 208     return err;
 209 }
 210 #endif
 211