1/*
2 Copyright (c) 2007-2017 Contributors as noted in the AUTHORS file
3
4 This file is part of libzmq, the ZeroMQ core engine in C++.
5
6 libzmq is free software; you can redistribute it and/or modify it under
7 the terms of the GNU Lesser General Public License (LGPL) as published
8 by the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 As a special exception, the Contributors give you permission to link
12 this library with independent modules to produce an executable,
13 regardless of the license terms of these independent modules, and to
14 copy and distribute the resulting executable under terms of your choice,
15 provided that you also meet, for each linked independent module, the
16 terms and conditions of the license of that module. An independent
17 module is a module which is not derived from or based on this library.
18 If you modify this library, you must extend this exception to your
19 version of the library.
20
21 libzmq is distributed in the hope that it will be useful, but WITHOUT
22 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
23 FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
24 License for more details.
25
26 You should have received a copy of the GNU Lesser General Public License
27 along with this program. If not, see <http://www.gnu.org/licenses/>.
28*/
29
30#include "precompiled.hpp"
31
32#include "macros.hpp"
33#include "clock.hpp"
34#include "err.hpp"
35#include "thread.hpp"
36#include "atomic_counter.hpp"
37#include "atomic_ptr.hpp"
38#include "random.hpp"
39#include <assert.h>
40#include <new>
41
42#if !defined ZMQ_HAVE_WINDOWS
43#include <unistd.h>
44#endif
45
46#if defined(ZMQ_USE_TWEETNACL)
47#include "tweetnacl.h"
48#elif defined(ZMQ_USE_LIBSODIUM)
49#include "sodium.h"
50#endif
51
52void zmq_sleep (int seconds_)
53{
54#if defined ZMQ_HAVE_WINDOWS
55 Sleep (seconds_ * 1000);
56#else
57 sleep (seconds_);
58#endif
59}
60
61void *zmq_stopwatch_start ()
62{
63 uint64_t *watch = static_cast<uint64_t *> (malloc (sizeof (uint64_t)));
64 alloc_assert (watch);
65 *watch = zmq::clock_t::now_us ();
66 return (void *) watch;
67}
68
69unsigned long zmq_stopwatch_intermediate (void *watch_)
70{
71 uint64_t end = zmq::clock_t::now_us ();
72 uint64_t start = *static_cast<uint64_t *> (watch_);
73 return static_cast<unsigned long> (end - start);
74}
75
76unsigned long zmq_stopwatch_stop (void *watch_)
77{
78 unsigned long res = zmq_stopwatch_intermediate (watch_);
79 free (watch_);
80 return res;
81}
82
83void *zmq_threadstart (zmq_thread_fn *func_, void *arg_)
84{
85 zmq::thread_t *thread = new (std::nothrow) zmq::thread_t;
86 alloc_assert (thread);
87 thread->start (func_, arg_, "ZMQapp");
88 return thread;
89}
90
91void zmq_threadclose (void *thread_)
92{
93 zmq::thread_t *p_thread = static_cast<zmq::thread_t *> (thread_);
94 p_thread->stop ();
95 LIBZMQ_DELETE (p_thread);
96}
97
98// Z85 codec, taken from 0MQ RFC project, implements RFC32 Z85 encoding
99
100// Maps base 256 to base 85
101static char encoder[85 + 1] = {"0123456789"
102 "abcdefghij"
103 "klmnopqrst"
104 "uvwxyzABCD"
105 "EFGHIJKLMN"
106 "OPQRSTUVWX"
107 "YZ.-:+=^!/"
108 "*?&<>()[]{"
109 "}@%$#"};
110
111// Maps base 85 to base 256
112// We chop off lower 32 and higher 128 ranges
113// 0xFF denotes invalid characters within this range
114static uint8_t decoder[96] = {
115 0xFF, 0x44, 0xFF, 0x54, 0x53, 0x52, 0x48, 0xFF, 0x4B, 0x4C, 0x46, 0x41,
116 0xFF, 0x3F, 0x3E, 0x45, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
117 0x08, 0x09, 0x40, 0xFF, 0x49, 0x42, 0x4A, 0x47, 0x51, 0x24, 0x25, 0x26,
118 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32,
119 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x4D,
120 0xFF, 0x4E, 0x43, 0xFF, 0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,
121 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C,
122 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x4F, 0xFF, 0x50, 0xFF, 0xFF};
123
124// --------------------------------------------------------------------------
125// Encode a binary frame as a string; destination string MUST be at least
126// size * 5 / 4 bytes long plus 1 byte for the null terminator. Returns
127// dest. Size must be a multiple of 4.
128// Returns NULL and sets errno = EINVAL for invalid input.
129
130char *zmq_z85_encode (char *dest_, const uint8_t *data_, size_t size_)
131{
132 if (size_ % 4 != 0) {
133 errno = EINVAL;
134 return NULL;
135 }
136 unsigned int char_nbr = 0;
137 unsigned int byte_nbr = 0;
138 uint32_t value = 0;
139 while (byte_nbr < size_) {
140 // Accumulate value in base 256 (binary)
141 value = value * 256 + data_[byte_nbr++];
142 if (byte_nbr % 4 == 0) {
143 // Output value in base 85
144 unsigned int divisor = 85 * 85 * 85 * 85;
145 while (divisor) {
146 dest_[char_nbr++] = encoder[value / divisor % 85];
147 divisor /= 85;
148 }
149 value = 0;
150 }
151 }
152 assert (char_nbr == size_ * 5 / 4);
153 dest_[char_nbr] = 0;
154 return dest_;
155}
156
157
158// --------------------------------------------------------------------------
159// Decode an encoded string into a binary frame; dest must be at least
160// strlen (string) * 4 / 5 bytes long. Returns dest. strlen (string)
161// must be a multiple of 5.
162// Returns NULL and sets errno = EINVAL for invalid input.
163
164uint8_t *zmq_z85_decode (uint8_t *dest_, const char *string_)
165{
166 unsigned int byte_nbr = 0;
167 unsigned int char_nbr = 0;
168 uint32_t value = 0;
169 while (string_[char_nbr]) {
170 // Accumulate value in base 85
171 if (UINT32_MAX / 85 < value) {
172 // Invalid z85 encoding, represented value exceeds 0xffffffff
173 goto error_inval;
174 }
175 value *= 85;
176 uint8_t index = string_[char_nbr++] - 32;
177 if (index >= sizeof (decoder)) {
178 // Invalid z85 encoding, character outside range
179 goto error_inval;
180 }
181 uint32_t summand = decoder[index];
182 if (summand == 0xFF || summand > (UINT32_MAX - value)) {
183 // Invalid z85 encoding, invalid character or represented value exceeds 0xffffffff
184 goto error_inval;
185 }
186 value += summand;
187 if (char_nbr % 5 == 0) {
188 // Output value in base 256
189 unsigned int divisor = 256 * 256 * 256;
190 while (divisor) {
191 dest_[byte_nbr++] = value / divisor % 256;
192 divisor /= 256;
193 }
194 value = 0;
195 }
196 }
197 if (char_nbr % 5 != 0) {
198 goto error_inval;
199 }
200 assert (byte_nbr == strlen (string_) * 4 / 5);
201 return dest_;
202
203error_inval:
204 errno = EINVAL;
205 return NULL;
206}
207
208// --------------------------------------------------------------------------
209// Generate a public/private keypair with tweetnacl or libsodium.
210// Generated keys will be 40 byte z85-encoded strings.
211// Returns 0 on success, -1 on failure, setting errno.
212// Sets errno = ENOTSUP in the absence of a CURVE library.
213
214int zmq_curve_keypair (char *z85_public_key_, char *z85_secret_key_)
215{
216#if defined(ZMQ_HAVE_CURVE)
217#if crypto_box_PUBLICKEYBYTES != 32 || crypto_box_SECRETKEYBYTES != 32
218#error "CURVE encryption library not built correctly"
219#endif
220
221 uint8_t public_key[32];
222 uint8_t secret_key[32];
223
224 zmq::random_open ();
225
226 int res = crypto_box_keypair (public_key, secret_key);
227 zmq_z85_encode (z85_public_key_, public_key, 32);
228 zmq_z85_encode (z85_secret_key_, secret_key, 32);
229
230 zmq::random_close ();
231
232 return res;
233#else
234 (void) z85_public_key_, (void) z85_secret_key_;
235 errno = ENOTSUP;
236 return -1;
237#endif
238}
239
240// --------------------------------------------------------------------------
241// Derive the public key from a private key using tweetnacl or libsodium.
242// Derived key will be 40 byte z85-encoded string.
243// Returns 0 on success, -1 on failure, setting errno.
244// Sets errno = ENOTSUP in the absence of a CURVE library.
245
246int zmq_curve_public (char *z85_public_key_, const char *z85_secret_key_)
247{
248#if defined(ZMQ_HAVE_CURVE)
249#if crypto_box_PUBLICKEYBYTES != 32 || crypto_box_SECRETKEYBYTES != 32
250#error "CURVE encryption library not built correctly"
251#endif
252
253 uint8_t public_key[32];
254 uint8_t secret_key[32];
255
256 zmq::random_open ();
257
258 if (zmq_z85_decode (secret_key, z85_secret_key_) == NULL)
259 return -1;
260
261 // Return codes are suppressed as none of these can actually fail.
262 crypto_scalarmult_base (public_key, secret_key);
263 zmq_z85_encode (z85_public_key_, public_key, 32);
264
265 zmq::random_close ();
266
267 return 0;
268#else
269 (void) z85_public_key_, (void) z85_secret_key_;
270 errno = ENOTSUP;
271 return -1;
272#endif
273}
274
275
276// --------------------------------------------------------------------------
277// Initialize a new atomic counter, which is set to zero
278
279void *zmq_atomic_counter_new (void)
280{
281 zmq::atomic_counter_t *counter = new (std::nothrow) zmq::atomic_counter_t;
282 alloc_assert (counter);
283 return counter;
284}
285
286// Se the value of the atomic counter
287
288void zmq_atomic_counter_set (void *counter_, int value_)
289{
290 (static_cast<zmq::atomic_counter_t *> (counter_))->set (value_);
291}
292
293// Increment the atomic counter, and return the old value
294
295int zmq_atomic_counter_inc (void *counter_)
296{
297 return (static_cast<zmq::atomic_counter_t *> (counter_))->add (1);
298}
299
300// Decrement the atomic counter and return 1 (if counter >= 1), or
301// 0 if counter hit zero.
302
303int zmq_atomic_counter_dec (void *counter_)
304{
305 return (static_cast<zmq::atomic_counter_t *> (counter_))->sub (1) ? 1 : 0;
306}
307
308// Return actual value of atomic counter
309
310int zmq_atomic_counter_value (void *counter_)
311{
312 return (static_cast<zmq::atomic_counter_t *> (counter_))->get ();
313}
314
315// Destroy atomic counter, and set reference to NULL
316
317void zmq_atomic_counter_destroy (void **counter_p_)
318{
319 delete (static_cast<zmq::atomic_counter_t *> (*counter_p_));
320 *counter_p_ = NULL;
321}
322