robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 1 | /* |
robert.swiecki@gmail.com | 3b630b4 | 2015-02-16 10:53:53 +0000 | [diff] [blame] | 2 | * |
robert.swiecki@gmail.com | 97c7733 | 2015-02-14 23:06:58 +0000 | [diff] [blame] | 3 | * honggfuzz - utilities |
| 4 | * ----------------------------------------- |
robert.swiecki@gmail.com | 3b630b4 | 2015-02-16 10:53:53 +0000 | [diff] [blame] | 5 | * |
robert.swiecki@gmail.com | 772b33d | 2015-02-14 20:35:00 +0000 | [diff] [blame] | 6 | * Author: Robert Swiecki <swiecki@google.com> |
robert.swiecki@gmail.com | 3b630b4 | 2015-02-16 10:53:53 +0000 | [diff] [blame] | 7 | * |
robert.swiecki@gmail.com | 772b33d | 2015-02-14 20:35:00 +0000 | [diff] [blame] | 8 | * Copyright 2010-2015 by Google Inc. All Rights Reserved. |
robert.swiecki@gmail.com | 3b630b4 | 2015-02-16 10:53:53 +0000 | [diff] [blame] | 9 | * |
| 10 | * Licensed under the Apache License, Version 2.0 (the "License"); you may |
| 11 | * not use this file except in compliance with the License. You may obtain |
robert.swiecki@gmail.com | 772b33d | 2015-02-14 20:35:00 +0000 | [diff] [blame] | 12 | * a copy of the License at |
robert.swiecki@gmail.com | 3b630b4 | 2015-02-16 10:53:53 +0000 | [diff] [blame] | 13 | * |
robert.swiecki@gmail.com | 772b33d | 2015-02-14 20:35:00 +0000 | [diff] [blame] | 14 | * http://www.apache.org/licenses/LICENSE-2.0 |
robert.swiecki@gmail.com | 3b630b4 | 2015-02-16 10:53:53 +0000 | [diff] [blame] | 15 | * |
robert.swiecki@gmail.com | 772b33d | 2015-02-14 20:35:00 +0000 | [diff] [blame] | 16 | * Unless required by applicable law or agreed to in writing, software |
| 17 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 18 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
| 19 | * implied. See the License for the specific language governing |
| 20 | * permissions and limitations under the License. |
robert.swiecki@gmail.com | 3b630b4 | 2015-02-16 10:53:53 +0000 | [diff] [blame] | 21 | * |
robert.swiecki@gmail.com | 772b33d | 2015-02-14 20:35:00 +0000 | [diff] [blame] | 22 | */ |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 23 | |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 24 | #include <fcntl.h> |
Robert Swiecki | c8c32db | 2015-10-09 18:06:22 +0200 | [diff] [blame] | 25 | #include <inttypes.h> |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 26 | #include <math.h> |
robert.swiecki@gmail.com | e7190b9 | 2015-02-14 23:05:42 +0000 | [diff] [blame] | 27 | #include <stdarg.h> |
robert.swiecki@gmail.com | ba85c3e | 2015-02-02 14:55:16 +0000 | [diff] [blame] | 28 | #include <stdint.h> |
robert.swiecki@gmail.com | e7190b9 | 2015-02-14 23:05:42 +0000 | [diff] [blame] | 29 | #include <stdio.h> |
robert.swiecki@gmail.com | ba85c3e | 2015-02-02 14:55:16 +0000 | [diff] [blame] | 30 | #include <stdlib.h> |
robert.swiecki@gmail.com | e7190b9 | 2015-02-14 23:05:42 +0000 | [diff] [blame] | 31 | #include <string.h> |
robert.swiecki@gmail.com | ba85c3e | 2015-02-02 14:55:16 +0000 | [diff] [blame] | 32 | #include <sys/stat.h> |
| 33 | #include <sys/time.h> |
| 34 | #include <sys/types.h> |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 35 | #include <time.h> |
robert.swiecki@gmail.com | ba85c3e | 2015-02-02 14:55:16 +0000 | [diff] [blame] | 36 | #include <unistd.h> |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 37 | |
| 38 | #include "common.h" |
robert.swiecki@gmail.com | 26a9ab7 | 2015-02-22 13:41:18 +0000 | [diff] [blame] | 39 | #include "files.h" |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 40 | #include "log.h" |
| 41 | |
Anestis Bechtsoudis | 4f9bfd0 | 2015-09-10 17:31:58 +0300 | [diff] [blame] | 42 | #if defined(__builtin_bswap16) |
| 43 | #define SWAP16(x) __builtin_bswap16(x) |
| 44 | #else |
| 45 | #define SWAP16(x) ((x & 0xff) << 8) | ((x & 0xff00) >> 8) |
| 46 | #endif |
| 47 | |
| 48 | #if defined(__builtin_bswap32) |
| 49 | #define SWAP32(x) __builtin_bswap32(x) |
| 50 | #else |
| 51 | #define SWAP32(x) ((x & 0xff) << 24) | ((x & 0xff00) << 8) | ((x & 0xff0000) >> 8) | ((x & 0xff000000) >> 24) |
| 52 | #endif |
| 53 | |
robert.swiecki@gmail.com | 26a9ab7 | 2015-02-22 13:41:18 +0000 | [diff] [blame] | 54 | static int util_urandomFd = -1; |
Jagger | 2e518b5 | 2015-09-24 04:01:16 +0200 | [diff] [blame] | 55 | static __thread uint64_t rndX; |
| 56 | static __thread uint64_t rndIni = false; |
robert.swiecki@gmail.com | 180263f | 2015-02-13 13:57:15 +0000 | [diff] [blame] | 57 | |
robert.swiecki@gmail.com | 90e9911 | 2015-02-15 02:05:14 +0000 | [diff] [blame] | 58 | uint64_t util_rndGet(uint64_t min, uint64_t max) |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 59 | { |
Jagger | 2e518b5 | 2015-09-24 04:01:16 +0200 | [diff] [blame] | 60 | if (min > max) { |
Anestis Bechtsoudis | 07e14ce | 2015-12-30 14:15:42 +0200 | [diff] [blame] | 61 | LOG_F("min:%" PRIu64 " > max:%" PRIu64, min, max); |
Jagger | 2e518b5 | 2015-09-24 04:01:16 +0200 | [diff] [blame] | 62 | } |
| 63 | |
robert.swiecki@gmail.com | 26a9ab7 | 2015-02-22 13:41:18 +0000 | [diff] [blame] | 64 | if (util_urandomFd == -1) { |
| 65 | if ((util_urandomFd = open("/dev/urandom", O_RDONLY)) == -1) { |
Robert Swiecki | c8c32db | 2015-10-09 18:06:22 +0200 | [diff] [blame] | 66 | PLOG_F("Couldn't open /dev/urandom for writing"); |
robert.swiecki@gmail.com | 26a9ab7 | 2015-02-22 13:41:18 +0000 | [diff] [blame] | 67 | } |
robert.swiecki@gmail.com | 180263f | 2015-02-13 13:57:15 +0000 | [diff] [blame] | 68 | } |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 69 | |
Jagger | 2e518b5 | 2015-09-24 04:01:16 +0200 | [diff] [blame] | 70 | if (rndIni == false) { |
Jagger | 4d10985 | 2016-02-04 02:28:44 +0100 | [diff] [blame] | 71 | if (files_readFromFd(util_urandomFd, (uint8_t *) & rndX, sizeof(rndX)) != sizeof(rndX)) { |
Robert Swiecki | c8c32db | 2015-10-09 18:06:22 +0200 | [diff] [blame] | 72 | PLOG_F("Couldn't read '%zu' bytes from /dev/urandom", sizeof(rndX)); |
Jagger | 2e518b5 | 2015-09-24 04:01:16 +0200 | [diff] [blame] | 73 | } |
| 74 | rndIni = true; |
robert.swiecki@gmail.com | 4be12dc | 2015-02-13 14:03:53 +0000 | [diff] [blame] | 75 | } |
robert.swiecki@gmail.com | 180263f | 2015-02-13 13:57:15 +0000 | [diff] [blame] | 76 | |
Jagger | 2e518b5 | 2015-09-24 04:01:16 +0200 | [diff] [blame] | 77 | /* MMIX LCG PRNG */ |
| 78 | static const uint64_t a = 6364136223846793005ULL; |
| 79 | static const uint64_t c = 1442695040888963407ULL; |
robert.swiecki@gmail.com | bce825a | 2015-02-13 23:26:07 +0000 | [diff] [blame] | 80 | |
Jagger | 2e518b5 | 2015-09-24 04:01:16 +0200 | [diff] [blame] | 81 | rndX = (a * rndX + c); |
| 82 | |
| 83 | return ((rndX % (max - min + 1)) + min); |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 84 | } |
| 85 | |
robert.swiecki@gmail.com | 89cc38c | 2015-02-23 02:52:08 +0000 | [diff] [blame] | 86 | void util_rndBuf(uint8_t * buf, size_t sz) |
| 87 | { |
robert.swiecki@gmail.com | ace4086 | 2015-03-08 07:09:56 +0000 | [diff] [blame] | 88 | /* MMIX LCG PRNG */ |
Jagger | 89085f9 | 2015-09-24 04:45:53 +0200 | [diff] [blame] | 89 | static const uint64_t a = 6364136223846793005ULL; |
| 90 | static const uint64_t c = 1442695040888963407ULL; |
| 91 | uint64_t x = util_rndGet(0, 1ULL << 62); |
robert.swiecki@gmail.com | 89cc38c | 2015-02-23 02:52:08 +0000 | [diff] [blame] | 92 | |
robert.swiecki@gmail.com | 08174c7 | 2015-02-28 14:38:06 +0000 | [diff] [blame] | 93 | for (size_t i = 0; i < sz; i++) { |
robert.swiecki@gmail.com | ace4086 | 2015-03-08 07:09:56 +0000 | [diff] [blame] | 94 | x = (a * x + c); |
Jagger | 89085f9 | 2015-09-24 04:45:53 +0200 | [diff] [blame] | 95 | buf[i] = (uint8_t) (x & 0xFF); |
robert.swiecki@gmail.com | 89cc38c | 2015-02-23 02:52:08 +0000 | [diff] [blame] | 96 | } |
robert.swiecki@gmail.com | 89cc38c | 2015-02-23 02:52:08 +0000 | [diff] [blame] | 97 | } |
| 98 | |
Robert Swiecki | 23ec02a | 2016-01-19 18:47:45 +0100 | [diff] [blame] | 99 | /* |
Anestis Bechtsoudis | be0ac7b | 2015-12-26 15:38:47 +0200 | [diff] [blame] | 100 | * Function has variable length stack size, although already we know it's invoked |
| 101 | * with relatively small sizes (max is _HF_REPORT_SIZE), thus safe to silent warning. |
| 102 | */ |
| 103 | #pragma GCC diagnostic push |
Anestis Bechtsoudis | 539dbc5 | 2015-12-26 20:11:46 +0200 | [diff] [blame] | 104 | #pragma GCC diagnostic ignored "-Wframe-larger-than=" |
robert.swiecki@gmail.com | 9e2d43d | 2015-02-16 12:17:39 +0000 | [diff] [blame] | 105 | int util_vssnprintf(char *str, size_t size, const char *format, va_list ap) |
| 106 | { |
| 107 | char buf1[size]; |
| 108 | char buf2[size]; |
| 109 | |
| 110 | strncpy(buf1, str, size); |
| 111 | |
| 112 | vsnprintf(buf2, size, format, ap); |
| 113 | |
| 114 | return snprintf(str, size, "%s%s", buf1, buf2); |
| 115 | } |
| 116 | |
| 117 | int util_ssnprintf(char *str, size_t size, const char *format, ...) |
robert.swiecki@gmail.com | e7190b9 | 2015-02-14 23:05:42 +0000 | [diff] [blame] | 118 | { |
| 119 | char buf1[size]; |
| 120 | char buf2[size]; |
| 121 | |
| 122 | strncpy(buf1, str, size); |
| 123 | |
| 124 | va_list args; |
| 125 | va_start(args, format); |
| 126 | vsnprintf(buf2, size, format, args); |
| 127 | va_end(args); |
| 128 | |
robert.swiecki@gmail.com | 9e2d43d | 2015-02-16 12:17:39 +0000 | [diff] [blame] | 129 | return snprintf(str, size, "%s%s", buf1, buf2); |
robert.swiecki@gmail.com | e7190b9 | 2015-02-14 23:05:42 +0000 | [diff] [blame] | 130 | } |
| 131 | |
Anestis Bechtsoudis | be0ac7b | 2015-12-26 15:38:47 +0200 | [diff] [blame] | 132 | #pragma GCC diagnostic pop /* EOF diagnostic ignored "-Wstack-usage=" */ |
| 133 | |
Robert Swiecki | 81c6a0d | 2015-09-08 15:43:20 +0200 | [diff] [blame] | 134 | void util_getLocalTime(const char *fmt, char *buf, size_t len, time_t tm) |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 135 | { |
| 136 | struct tm ltime; |
Robert Swiecki | 81c6a0d | 2015-09-08 15:43:20 +0200 | [diff] [blame] | 137 | localtime_r(&tm, <ime); |
| 138 | if (strftime(buf, len, fmt, <ime) < 1) { |
| 139 | snprintf(buf, len, "[date fetch error]"); |
| 140 | } |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 141 | } |
| 142 | |
robert.swiecki | 40499ff | 2010-12-13 19:47:08 +0000 | [diff] [blame] | 143 | void util_nullifyStdio(void) |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 144 | { |
| 145 | int fd = open("/dev/null", O_RDWR); |
| 146 | |
| 147 | if (fd == -1) { |
Robert Swiecki | c8c32db | 2015-10-09 18:06:22 +0200 | [diff] [blame] | 148 | PLOG_E("Couldn't open '/dev/null'"); |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 149 | return; |
| 150 | } |
| 151 | |
| 152 | dup2(fd, 0); |
| 153 | dup2(fd, 1); |
| 154 | dup2(fd, 2); |
| 155 | |
| 156 | if (fd > 2) { |
| 157 | close(fd); |
| 158 | } |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 159 | } |
| 160 | |
| 161 | bool util_redirectStdin(char *inputFile) |
| 162 | { |
| 163 | int fd = open(inputFile, O_RDONLY); |
| 164 | |
| 165 | if (fd == -1) { |
Robert Swiecki | c8c32db | 2015-10-09 18:06:22 +0200 | [diff] [blame] | 166 | PLOG_E("Couldn't open '%s'", inputFile); |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 167 | return false; |
| 168 | } |
| 169 | |
| 170 | dup2(fd, 0); |
| 171 | if (fd != 0) { |
| 172 | close(fd); |
| 173 | } |
| 174 | |
| 175 | return true; |
| 176 | } |
| 177 | |
robert.swiecki | 40499ff | 2010-12-13 19:47:08 +0000 | [diff] [blame] | 178 | void util_recoverStdio(void) |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 179 | { |
| 180 | int fd = open("/dev/tty", O_RDWR); |
| 181 | |
| 182 | if (fd == -1) { |
Robert Swiecki | c8c32db | 2015-10-09 18:06:22 +0200 | [diff] [blame] | 183 | PLOG_E("Couldn't open '/dev/tty'"); |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 184 | return; |
| 185 | } |
| 186 | |
| 187 | dup2(fd, 0); |
| 188 | dup2(fd, 1); |
| 189 | dup2(fd, 2); |
| 190 | |
robert.swiecki@gmail.com | df28694 | 2015-04-15 21:45:25 +0000 | [diff] [blame] | 191 | if (tcsetpgrp(fd, getpid()) == -1) { |
Robert Swiecki | c8c32db | 2015-10-09 18:06:22 +0200 | [diff] [blame] | 192 | PLOG_W("tcsetpgrp(%d) failed", getpid()); |
robert.swiecki@gmail.com | df28694 | 2015-04-15 21:45:25 +0000 | [diff] [blame] | 193 | } |
| 194 | |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 195 | if (fd > 2) { |
| 196 | close(fd); |
| 197 | } |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 198 | } |
groebert@google.com | 1bd4c21 | 2013-06-19 11:13:56 +0000 | [diff] [blame] | 199 | |
robert.swiecki@gmail.com | 772b33d | 2015-02-14 20:35:00 +0000 | [diff] [blame] | 200 | /* |
robert.swiecki@gmail.com | 3b630b4 | 2015-02-16 10:53:53 +0000 | [diff] [blame] | 201 | * This is not a cryptographically secure hash |
robert.swiecki@gmail.com | 772b33d | 2015-02-14 20:35:00 +0000 | [diff] [blame] | 202 | */ |
Anestis Bechtsoudis | 3857255 | 2016-02-07 12:55:55 +0200 | [diff] [blame^] | 203 | uint64_t util_hash(const char *buf, size_t len) |
groebert@google.com | 1bd4c21 | 2013-06-19 11:13:56 +0000 | [diff] [blame] | 204 | { |
| 205 | uint64_t ret = 0; |
| 206 | |
| 207 | for (size_t i = 0; i < len; i++) { |
| 208 | ret += buf[i]; |
| 209 | ret += (ret << 10); |
| 210 | ret ^= (ret >> 6); |
| 211 | } |
| 212 | |
| 213 | return ret; |
| 214 | } |
robert.swiecki@gmail.com | 549ff18 | 2015-02-28 22:38:00 +0000 | [diff] [blame] | 215 | |
Anestis Bechtsoudis | 3857255 | 2016-02-07 12:55:55 +0200 | [diff] [blame^] | 216 | int64_t util_timeNowMillis(void) |
robert.swiecki@gmail.com | 3213a11 | 2015-03-12 01:42:02 +0000 | [diff] [blame] | 217 | { |
| 218 | struct timeval tv; |
| 219 | if (gettimeofday(&tv, NULL) == -1) { |
Robert Swiecki | c8c32db | 2015-10-09 18:06:22 +0200 | [diff] [blame] | 220 | PLOG_F("gettimeofday()"); |
robert.swiecki@gmail.com | 3213a11 | 2015-03-12 01:42:02 +0000 | [diff] [blame] | 221 | } |
| 222 | |
| 223 | return (((int64_t) tv.tv_sec * 1000LL) + ((int64_t) tv.tv_usec / 1000LL)); |
| 224 | } |
| 225 | |
Anestis Bechtsoudis | 3857255 | 2016-02-07 12:55:55 +0200 | [diff] [blame^] | 226 | uint16_t util_ToFromBE16(uint16_t val) |
robert.swiecki@gmail.com | 549ff18 | 2015-02-28 22:38:00 +0000 | [diff] [blame] | 227 | { |
| 228 | #if __BYTE_ORDER == __BIG_ENDIAN |
| 229 | return val; |
| 230 | #elif __BYTE_ORDER == __LITTLE_ENDIAN |
Anestis Bechtsoudis | 4f9bfd0 | 2015-09-10 17:31:58 +0300 | [diff] [blame] | 231 | return SWAP16(val); |
robert.swiecki@gmail.com | 549ff18 | 2015-02-28 22:38:00 +0000 | [diff] [blame] | 232 | #else |
Anestis Bechtsoudis | be0ac7b | 2015-12-26 15:38:47 +0200 | [diff] [blame] | 233 | #error "Unknown ENDIANNESS" |
robert.swiecki@gmail.com | 549ff18 | 2015-02-28 22:38:00 +0000 | [diff] [blame] | 234 | #endif |
| 235 | } |
| 236 | |
Anestis Bechtsoudis | 3857255 | 2016-02-07 12:55:55 +0200 | [diff] [blame^] | 237 | uint16_t util_ToFromLE16(uint16_t val) |
robert.swiecki@gmail.com | 549ff18 | 2015-02-28 22:38:00 +0000 | [diff] [blame] | 238 | { |
| 239 | #if __BYTE_ORDER == __BIG_ENDIAN |
Anestis Bechtsoudis | 4f9bfd0 | 2015-09-10 17:31:58 +0300 | [diff] [blame] | 240 | return SWAP16(val); |
robert.swiecki@gmail.com | 549ff18 | 2015-02-28 22:38:00 +0000 | [diff] [blame] | 241 | #elif __BYTE_ORDER == __LITTLE_ENDIAN |
| 242 | return val; |
| 243 | #else |
Anestis Bechtsoudis | be0ac7b | 2015-12-26 15:38:47 +0200 | [diff] [blame] | 244 | #error "Unknown ENDIANNESS" |
robert.swiecki@gmail.com | 549ff18 | 2015-02-28 22:38:00 +0000 | [diff] [blame] | 245 | #endif |
| 246 | } |
| 247 | |
Anestis Bechtsoudis | 3857255 | 2016-02-07 12:55:55 +0200 | [diff] [blame^] | 248 | uint32_t util_ToFromBE32(uint32_t val) |
robert.swiecki@gmail.com | 549ff18 | 2015-02-28 22:38:00 +0000 | [diff] [blame] | 249 | { |
| 250 | #if __BYTE_ORDER == __BIG_ENDIAN |
| 251 | return val; |
| 252 | #elif __BYTE_ORDER == __LITTLE_ENDIAN |
Anestis Bechtsoudis | 4f9bfd0 | 2015-09-10 17:31:58 +0300 | [diff] [blame] | 253 | return SWAP32(val); |
robert.swiecki@gmail.com | 549ff18 | 2015-02-28 22:38:00 +0000 | [diff] [blame] | 254 | #else |
Anestis Bechtsoudis | be0ac7b | 2015-12-26 15:38:47 +0200 | [diff] [blame] | 255 | #error "Unknown ENDIANNESS" |
robert.swiecki@gmail.com | 549ff18 | 2015-02-28 22:38:00 +0000 | [diff] [blame] | 256 | #endif |
| 257 | } |
| 258 | |
Anestis Bechtsoudis | 3857255 | 2016-02-07 12:55:55 +0200 | [diff] [blame^] | 259 | uint32_t util_ToFromLE32(uint32_t val) |
robert.swiecki@gmail.com | 549ff18 | 2015-02-28 22:38:00 +0000 | [diff] [blame] | 260 | { |
| 261 | #if __BYTE_ORDER == __BIG_ENDIAN |
Anestis Bechtsoudis | 4f9bfd0 | 2015-09-10 17:31:58 +0300 | [diff] [blame] | 262 | return SWAP32(val); |
robert.swiecki@gmail.com | 549ff18 | 2015-02-28 22:38:00 +0000 | [diff] [blame] | 263 | #elif __BYTE_ORDER == __LITTLE_ENDIAN |
| 264 | return val; |
| 265 | #else |
Anestis Bechtsoudis | be0ac7b | 2015-12-26 15:38:47 +0200 | [diff] [blame] | 266 | #error "Unknown ENDIANNESS" |
| 267 | #endif |
| 268 | } |
| 269 | |
Anestis Bechtsoudis | 3857255 | 2016-02-07 12:55:55 +0200 | [diff] [blame^] | 270 | uint64_t util_getUINT32(const uint8_t * buf) |
Anestis Bechtsoudis | be0ac7b | 2015-12-26 15:38:47 +0200 | [diff] [blame] | 271 | { |
| 272 | const uint8_t b0 = buf[0], b1 = buf[1], b2 = buf[2], b3 = buf[3]; |
| 273 | |
| 274 | #if __BYTE_ORDER == __BIG_ENDIAN |
Anestis Bechtsoudis | a16f70f | 2016-01-03 13:03:21 +0200 | [diff] [blame] | 275 | return (uint64_t) ((uint32_t) b0 << 24) | ((uint32_t) b1 << 16) | ((uint32_t) b2 << 8) | |
| 276 | (uint32_t) b3; |
Anestis Bechtsoudis | be0ac7b | 2015-12-26 15:38:47 +0200 | [diff] [blame] | 277 | #elif __BYTE_ORDER == __LITTLE_ENDIAN |
Anestis Bechtsoudis | a16f70f | 2016-01-03 13:03:21 +0200 | [diff] [blame] | 278 | return (uint64_t) ((uint32_t) b3 << 24) | ((uint32_t) b2 << 16) | ((uint32_t) b1 << 8) | |
| 279 | (uint32_t) b0; |
Anestis Bechtsoudis | be0ac7b | 2015-12-26 15:38:47 +0200 | [diff] [blame] | 280 | #else |
| 281 | #error "Unknown ENDIANNESS" |
| 282 | #endif |
| 283 | } |
| 284 | |
Anestis Bechtsoudis | 3857255 | 2016-02-07 12:55:55 +0200 | [diff] [blame^] | 285 | uint64_t util_getUINT64(const uint8_t * buf) |
Anestis Bechtsoudis | be0ac7b | 2015-12-26 15:38:47 +0200 | [diff] [blame] | 286 | { |
| 287 | const uint8_t b0 = buf[0], b1 = buf[1], b2 = buf[2], b3 = buf[3], |
| 288 | b4 = buf[4], b5 = buf[5], b6 = buf[6], b7 = buf[7]; |
| 289 | |
| 290 | #if __BYTE_ORDER == __BIG_ENDIAN |
Anestis Bechtsoudis | f2a5bc6 | 2015-12-26 18:41:48 +0200 | [diff] [blame] | 291 | return ((uint64_t) b0 << 56) | ((uint64_t) b1 << 48) | ((uint64_t) b2 << 40) | |
| 292 | ((uint64_t) b3 << 32) | ((uint64_t) b4 << 24) | ((uint64_t) b5 << 16) | |
| 293 | ((uint64_t) b6 << 8) | (uint64_t) b7; |
Anestis Bechtsoudis | be0ac7b | 2015-12-26 15:38:47 +0200 | [diff] [blame] | 294 | #elif __BYTE_ORDER == __LITTLE_ENDIAN |
Anestis Bechtsoudis | f2a5bc6 | 2015-12-26 18:41:48 +0200 | [diff] [blame] | 295 | return ((uint64_t) b7 << 56) | ((uint64_t) b6 << 48) | ((uint64_t) b5 << 40) | |
| 296 | ((uint64_t) b4 << 32) | ((uint64_t) b3 << 24) | ((uint64_t) b2 << 16) | |
| 297 | ((uint64_t) b1 << 8) | (uint64_t) b0; |
Anestis Bechtsoudis | be0ac7b | 2015-12-26 15:38:47 +0200 | [diff] [blame] | 298 | #else |
| 299 | #error "Unknown ENDIANNESS" |
robert.swiecki@gmail.com | 549ff18 | 2015-02-28 22:38:00 +0000 | [diff] [blame] | 300 | #endif |
| 301 | } |
Jagger | 421aca8 | 2015-09-05 14:09:47 +0200 | [diff] [blame] | 302 | |
Anestis Bechtsoudis | 3857255 | 2016-02-07 12:55:55 +0200 | [diff] [blame^] | 303 | void MX_LOCK(pthread_mutex_t * mutex) |
Jagger | 421aca8 | 2015-09-05 14:09:47 +0200 | [diff] [blame] | 304 | { |
| 305 | if (pthread_mutex_lock(mutex)) { |
Robert Swiecki | c8c32db | 2015-10-09 18:06:22 +0200 | [diff] [blame] | 306 | PLOG_F("pthread_mutex_lock(%p)", mutex); |
Jagger | 421aca8 | 2015-09-05 14:09:47 +0200 | [diff] [blame] | 307 | } |
| 308 | } |
| 309 | |
Anestis Bechtsoudis | 3857255 | 2016-02-07 12:55:55 +0200 | [diff] [blame^] | 310 | void MX_UNLOCK(pthread_mutex_t * mutex) |
Jagger | 421aca8 | 2015-09-05 14:09:47 +0200 | [diff] [blame] | 311 | { |
| 312 | if (pthread_mutex_unlock(mutex)) { |
Robert Swiecki | c8c32db | 2015-10-09 18:06:22 +0200 | [diff] [blame] | 313 | PLOG_F("pthread_mutex_unlock(%p)", mutex); |
Jagger | 421aca8 | 2015-09-05 14:09:47 +0200 | [diff] [blame] | 314 | } |
| 315 | } |
Anestis Bechtsoudis | d59af69 | 2015-09-21 15:15:05 +0300 | [diff] [blame] | 316 | |
Anestis Bechtsoudis | 3857255 | 2016-02-07 12:55:55 +0200 | [diff] [blame^] | 317 | int64_t fastArray64Search(uint64_t * array, size_t arraySz, uint64_t key) |
Anestis Bechtsoudis | d59af69 | 2015-09-21 15:15:05 +0300 | [diff] [blame] | 318 | { |
| 319 | size_t low = 0; |
| 320 | size_t high = arraySz - 1; |
| 321 | size_t mid; |
| 322 | |
| 323 | while (array[high] != array[low] && key >= array[low] && key <= array[high]) { |
| 324 | mid = low + (key - array[low]) * ((high - low) / (array[high] - array[low])); |
| 325 | |
| 326 | if (array[mid] < key) { |
| 327 | low = mid + 1; |
| 328 | } else if (key < array[mid]) { |
| 329 | high = mid - 1; |
| 330 | } else { |
| 331 | return mid; |
| 332 | } |
| 333 | } |
| 334 | |
| 335 | if (key == array[low]) { |
| 336 | return low; |
| 337 | } else { |
| 338 | return -1; |
| 339 | } |
| 340 | } |