TAP line filter BIO.
[openssl.git] / test / testutil / format_output.c
1 /*
2  * Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include "../testutil.h"
11 #include "output.h"
12 #include "tu_local.h"
13
14 #include <string.h>
15 #include <ctype.h>
16 #include "../../e_os.h"
17
18 /* The size of memory buffers to display on failure */
19 #define MEM_BUFFER_SIZE     (2000)
20 #define MAX_STRING_WIDTH    (80)
21 #define BN_OUTPUT_SIZE      (8)
22
23 /* Output a diff header */
24 static void test_diff_header(const char *left, const char *right)
25 {
26     test_printf_stderr("--- %s\n", left);
27     test_printf_stderr("+++ %s\n", right);
28 }
29
30 /* Formatted string output routines */
31 static void test_string_null_empty(const char *m, char c)
32 {
33     if (m == NULL)
34         test_printf_stderr("% 4s %c NULL\n", "", c);
35     else
36         test_printf_stderr("% 4u:%c ''\n", 0u, c);
37 }
38
39 static void test_fail_string_common(const char *prefix, const char *file,
40                                     int line, const char *type,
41                                     const char *left, const char *right,
42                                     const char *op, const char *m1, size_t l1,
43                                     const char *m2, size_t l2)
44 {
45     const size_t width = (MAX_STRING_WIDTH - subtest_level() - 12) / 16 * 16;
46     char b1[MAX_STRING_WIDTH + 1], b2[MAX_STRING_WIDTH + 1];
47     char bdiff[MAX_STRING_WIDTH + 1];
48     size_t n1, n2, i;
49     unsigned int cnt = 0, diff;
50
51     test_fail_message_prefix(prefix, file, line, type, left, right, op);
52     if (m1 == NULL)
53         l1 = 0;
54     if (m2 == NULL)
55         l2 = 0;
56     if (l1 == 0 && l2 == 0) {
57         if ((m1 == NULL) == (m2 == NULL)) {
58             test_string_null_empty(m1, ' ');
59         } else {
60             test_diff_header(left, right);
61             test_string_null_empty(m1, '-');
62             test_string_null_empty(m2, '+');
63         }
64         goto fin;
65     }
66
67     if (l1 != l2 || strcmp(m1, m2) != 0)
68         test_diff_header(left, right);
69
70     while (l1 > 0 || l2 > 0) {
71         n1 = n2 = 0;
72         if (l1 > 0) {
73             b1[n1 = l1 > width ? width : l1] = 0;
74             for (i = 0; i < n1; i++)
75                 b1[i] = isprint(m1[i]) ? m1[i] : '.';
76         }
77         if (l2 > 0) {
78             b2[n2 = l2 > width ? width : l2] = 0;
79             for (i = 0; i < n2; i++)
80                 b2[i] = isprint(m2[i]) ? m2[i] : '.';
81         }
82         diff = 0;
83         i = 0;
84         if (n1 > 0 && n2 > 0) {
85             const size_t j = n1 < n2 ? n1 : n2;
86
87             for (; i < j; i++)
88                 if (m1[i] == m2[i]) {
89                     bdiff[i] = ' ';
90                 } else {
91                     bdiff[i] = '^';
92                     diff = 1;
93                 }
94             bdiff[i] = '\0';
95         }
96         if (n1 == n2 && !diff) {
97             test_printf_stderr("% 4u:  '%s'\n", cnt, n2 > n1 ? b2 : b1);
98         } else {
99             if (cnt == 0 && (m1 == NULL || *m1 == '\0'))
100                 test_string_null_empty(m1, '-');
101             else if (n1 > 0)
102                 test_printf_stderr("% 4u:- '%s'\n", cnt, b1);
103             if (cnt == 0 && (m2 == NULL || *m2 == '\0'))
104                test_string_null_empty(m2, '+');
105             else if (n2 > 0)
106                 test_printf_stderr("% 4u:+ '%s'\n", cnt, b2);
107             if (diff && i > 0)
108                 test_printf_stderr("% 4s    %s\n", "", bdiff);
109         }
110         m1 += n1;
111         m2 += n2;
112         l1 -= n1;
113         l2 -= n2;
114         cnt += width;
115     }
116 fin:
117     test_flush_stderr();
118 }
119
120 /*
121  * Wrapper routines so that the underlying code can be shared.
122  * The first is the call from inside the test utilities when a conditional
123  * fails.  The second is the user's call to dump a string.
124  */
125 void test_fail_string_message(const char *prefix, const char *file,
126                               int line, const char *type,
127                               const char *left, const char *right,
128                               const char *op, const char *m1, size_t l1,
129                               const char *m2, size_t l2)
130 {
131     test_fail_string_common(prefix, file, line, type, left, right, op,
132                             m1, l1, m2, l2);
133     test_printf_stderr("\n");
134 }
135
136 void test_output_string(const char *name, const char *m, size_t l)
137 {
138     test_fail_string_common("string", NULL, 0, NULL, NULL, NULL, name,
139                             m, l, m, l);
140 }
141
142 /* BIGNUM formatted output routines */
143
144 /*
145  * A basic memory byte to hex digit converter with allowance for spacing
146  * every so often.
147  */
148 static void hex_convert_memory(const unsigned char *m, size_t n, char *b,
149                                size_t width)
150 {
151     size_t i;
152
153     for (i = 0; i < n; i++) {
154         const unsigned char c = *m++;
155
156         *b++ = "0123456789abcdef"[c >> 4];
157         *b++ = "0123456789abcdef"[c & 15];
158         if (i % width == width - 1 && i != n - 1)
159             *b++ = ' ';
160     }
161     *b = '\0';
162 }
163
164 /*
165  * Constants to define the number of bytes to display per line and the number
166  * of characters these take.
167  */
168 static const int bn_bytes = (MAX_STRING_WIDTH - 9) / (BN_OUTPUT_SIZE * 2 + 1)
169                             * BN_OUTPUT_SIZE;
170 static const int bn_chars = (MAX_STRING_WIDTH - 9) / (BN_OUTPUT_SIZE * 2 + 1)
171                             * (BN_OUTPUT_SIZE * 2 + 1) - 1;
172
173 /*
174  * Output the header line for the bignum
175  */
176 static void test_bignum_header_line(void)
177 {
178     test_printf_stderr(" %*s\n", bn_chars + 6, "bit position");
179 }
180
181 static const char *test_bignum_zero_null(const BIGNUM *bn)
182 {
183     if (bn != NULL)
184         return BN_is_negative(bn) ? "-0" : "0";
185     return "NULL";
186 }
187
188 /*
189  * Print a bignum zero taking care to include the correct sign.
190  * This routine correctly deals with a NULL bignum pointer as input.
191  */
192 static void test_bignum_zero_print(const BIGNUM *bn, char sep)
193 {
194     const char *v = test_bignum_zero_null(bn);
195     const char *suf = bn != NULL ? ":    0" : "";
196
197     test_printf_stderr("%c%*s%s\n", sep, bn_chars, v, suf);
198 }
199
200 /*
201  * Convert a section of memory from inside a bignum into a displayable
202  * string with appropriate visual aid spaces inserted.
203  */
204 static int convert_bn_memory(const unsigned char *in, size_t bytes,
205                              char *out, int *lz, const BIGNUM *bn)
206 {
207     int n = bytes * 2, i;
208     char *p = out, *q = NULL;
209
210     if (bn != NULL && !BN_is_zero(bn)) {
211         hex_convert_memory(in, bytes, out, BN_OUTPUT_SIZE);
212         if (*lz) {
213             for (; *p == '0' || *p == ' '; p++)
214                 if (*p == '0') {
215                     q = p;
216                     *p = ' ';
217                     n--;
218                 }
219             if (*p == '\0') {
220                 /*
221                  * in[bytes] is defined because we're converting a non-zero
222                  * number and we've not seen a non-zero yet.
223                  */
224                 if ((in[bytes] & 0xf0) != 0 && BN_is_negative(bn)) {
225                     *lz = 0;
226                     *q = '-';
227                     n++;
228                 }
229             } else {
230                 *lz = 0;
231                 if (BN_is_negative(bn)) {
232                     /*
233                      * This is valid because we always convert more digits than
234                      * the number holds.
235                      */
236                     *q = '-';
237                     n++;
238                 }
239             }
240         }
241        return n;
242     }
243
244     for (i = 0; i < n; i++) {
245         *p++ = ' ';
246         if (i % (2 * BN_OUTPUT_SIZE) == 2 * BN_OUTPUT_SIZE - 1 && i != n - 1)
247             *p++ = ' ';
248     }
249     *p = '\0';
250     if (bn == NULL)
251         q = "NULL";
252     else
253         q = BN_is_negative(bn) ? "-0" : "0";
254     strcpy(p - strlen(q), q);
255     return 0;
256 }
257
258 /*
259  * Common code to display either one or two bignums, including the diff
260  * pointers for changes (only when there are two).
261  */
262 static void test_fail_bignum_common(const char *prefix, const char *file,
263                                     int line, const char *type,
264                                     const char *left, const char *right,
265                                     const char *op,
266                                     const BIGNUM *bn1, const BIGNUM *bn2)
267 {
268     const size_t bytes = bn_bytes;
269     char b1[MAX_STRING_WIDTH + 1], b2[MAX_STRING_WIDTH + 1];
270     char *p, bdiff[MAX_STRING_WIDTH + 1];
271     size_t l1, l2, n1, n2, i, len;
272     unsigned int cnt, diff, real_diff;
273     unsigned char *m1 = NULL, *m2 = NULL;
274     int lz1 = 1, lz2 = 1;
275     unsigned char buffer[MEM_BUFFER_SIZE * 2], *bufp = buffer;
276
277     test_fail_message_prefix(prefix, file, line, type, left, right, op);
278     l1 = bn1 == NULL ? 0 : (BN_num_bytes(bn1) + (BN_is_negative(bn1) ? 1 : 0));
279     l2 = bn2 == NULL ? 0 : (BN_num_bytes(bn2) + (BN_is_negative(bn2) ? 1 : 0));
280     if (l1 == 0 && l2 == 0) {
281         if ((bn1 == NULL) == (bn2 == NULL)) {
282             test_bignum_header_line();
283             test_bignum_zero_print(bn1, ' ');
284         } else {
285             test_diff_header(left, right);
286             test_bignum_header_line();
287             test_bignum_zero_print(bn1, '-');
288             test_bignum_zero_print(bn2, '+');
289         }
290         goto fin;
291     }
292
293     if (l1 != l2 || bn1 == NULL || bn2 == NULL || BN_cmp(bn1, bn2) != 0)
294         test_diff_header(left, right);
295     test_bignum_header_line();
296
297     len = ((l1 > l2 ? l1 : l2) + bytes - 1) / bytes * bytes;
298
299     if (len > MEM_BUFFER_SIZE && (bufp = OPENSSL_malloc(len * 2)) == NULL) {
300         bufp = buffer;
301         len = MEM_BUFFER_SIZE;
302         test_printf_stderr("WARNING: these BIGNUMs have been truncated");
303     }
304
305     if (bn1 != NULL) {
306         m1 = bufp;
307         BN_bn2binpad(bn1, m1, len);
308     }
309     if (bn2 != NULL) {
310         m2 = bufp + len;
311         BN_bn2binpad(bn2, m2, len);
312     }
313
314     while (len > 0) {
315         cnt = 8 * (len - bytes);
316         n1 = convert_bn_memory(m1, bytes, b1, &lz1, bn1);
317         n2 = convert_bn_memory(m2, bytes, b2, &lz2, bn2);
318
319         diff = real_diff = 0;
320         i = 0;
321         p = bdiff;
322         for (i=0; b1[i] != '\0'; i++)
323             if (b1[i] == b2[i] || b1[i] == ' ' || b2[i] == ' ') {
324                 *p++ = ' ';
325                 diff |= b1[i] != b2[i];
326             } else {
327                 *p++ = '^';
328                 real_diff = diff = 1;
329             }
330         *p++ = '\0';
331         if (!diff) {
332             test_printf_stderr(" %s:% 5d\n", n2 > n1 ? b2 : b1, cnt);
333         } else {
334             if (cnt == 0 && bn1 == NULL)
335                 test_printf_stderr("-%s\n", b1);
336             else if (cnt == 0 || n1 > 0)
337                 test_printf_stderr("-%s:% 5d\n", b1, cnt);
338             if (cnt == 0 && bn2 == NULL)
339                 test_printf_stderr("+%s\n", b2);
340             else if (cnt == 0 || n2 > 0)
341                 test_printf_stderr("+%s:% 5d\n", b2, cnt);
342             if (real_diff && (cnt == 0 || (n1 > 0 && n2 > 0))
343                     && bn1 != NULL && bn2 != NULL)
344                 test_printf_stderr(" %s\n", bdiff);
345         }
346         if (m1 != NULL)
347             m1 += bytes;
348         if (m2 != NULL)
349             m2 += bytes;
350         len -= bytes;
351     }
352 fin:
353     test_flush_stderr();
354     if (bufp != buffer)
355         OPENSSL_free(bufp);
356 }
357
358 /*
359  * Wrapper routines so that the underlying code can be shared.
360  * The first two are calls from inside the test utilities when a conditional
361  * fails.  The third is the user's call to dump a bignum.
362  */
363 void test_fail_bignum_message(const char *prefix, const char *file,
364                               int line, const char *type,
365                               const char *left, const char *right,
366                               const char *op,
367                               const BIGNUM *bn1, const BIGNUM *bn2)
368 {
369     test_fail_bignum_common(prefix, file, line, type, left, right, op, bn1, bn2);
370     test_printf_stderr("\n");
371 }
372
373 void test_fail_bignum_mono_message(const char *prefix, const char *file,
374                                    int line, const char *type,
375                                    const char *left, const char *right,
376                                    const char *op, const BIGNUM *bn)
377 {
378     test_fail_bignum_common(prefix, file, line, type, left, right, op, bn, bn);
379     test_printf_stderr("\n");
380 }
381
382 void test_output_bignum(const char *name, const BIGNUM *bn)
383 {
384     if (bn == NULL || BN_is_zero(bn)) {
385         test_printf_stderr("bignum: '%s' = %s", name,
386                            test_bignum_zero_null(bn));
387     } else if (BN_num_bytes(bn) <= BN_OUTPUT_SIZE) {
388         unsigned char buf[BN_OUTPUT_SIZE];
389         char out[2 * sizeof(buf) + 1];
390         char *p = out;
391         int n = BN_bn2bin(bn, buf);
392
393         hex_convert_memory(buf, n, p, BN_OUTPUT_SIZE);
394         while (*p == '0' && *++p != '\0')
395             ;
396         test_printf_stderr("bignum: '%s' = %s0x%s\n", name,
397                            BN_is_negative(bn) ? "-" : "", p);
398     } else {
399         test_fail_bignum_common("bignum", NULL, 0, NULL, NULL, NULL, name,
400                                 bn, bn);
401     }
402 }
403
404 /* Memory output routines */
405
406 /*
407  * Handle zero length blocks of memory or NULL pointers to memory
408  */
409 static void test_memory_null_empty(const unsigned char *m, char c)
410 {
411     if (m == NULL)
412         test_printf_stderr("% 4s %c%s\n", "", c, "NULL");
413     else
414         test_printf_stderr("%04x %c%s\n", 0u, c, "empty");
415 }
416
417 /*
418  * Common code to display one or two blocks of memory.
419  */
420 static void test_fail_memory_common(const char *prefix, const char *file,
421                                     int line, const char *type,
422                                     const char *left, const char *right,
423                                     const char *op,
424                                     const unsigned char *m1, size_t l1,
425                                     const unsigned char *m2, size_t l2)
426 {
427     const size_t bytes = (MAX_STRING_WIDTH - 9) / 17 * 8;
428     char b1[MAX_STRING_WIDTH + 1], b2[MAX_STRING_WIDTH + 1];
429     char *p, bdiff[MAX_STRING_WIDTH + 1];
430     size_t n1, n2, i;
431     unsigned int cnt = 0, diff;
432
433     test_fail_message_prefix(prefix, file, line, type, left, right, op);
434     if (m1 == NULL)
435         l1 = 0;
436     if (m2 == NULL)
437         l2 = 0;
438     if (l1 == 0 && l2 == 0) {
439         if ((m1 == NULL) == (m2 == NULL)) {
440             test_memory_null_empty(m1, ' ');
441         } else {
442             test_diff_header(left, right);
443             test_memory_null_empty(m1, '-');
444             test_memory_null_empty(m2, '+');
445         }
446         goto fin;
447     }
448
449     if (l1 != l2 || (m1 != m2 && memcmp(m1, m2, l1) != 0))
450         test_diff_header(left, right);
451
452     while (l1 > 0 || l2 > 0) {
453         n1 = n2 = 0;
454         if (l1 > 0) {
455             n1 = l1 > bytes ? bytes : l1;
456             hex_convert_memory(m1, n1, b1, 8);
457         }
458         if (l2 > 0) {
459             n2 = l2 > bytes ? bytes : l2;
460             hex_convert_memory(m2, n2, b2, 8);
461         }
462
463         diff = 0;
464         i = 0;
465         p = bdiff;
466         if (n1 > 0 && n2 > 0) {
467             const size_t j = n1 < n2 ? n1 : n2;
468
469             for (; i < j; i++) {
470                 if (m1[i] == m2[i]) {
471                     *p++ = ' ';
472                     *p++ = ' ';
473                 } else {
474                     *p++ = '^';
475                     *p++ = '^';
476                     diff = 1;
477                 }
478                 if (i % 8 == 7 && i != j - 1)
479                     *p++ = ' ';
480             }
481             *p++ = '\0';
482         }
483
484         if (n1 == n2 && !diff) {
485             test_printf_stderr("%04x: %s\n", cnt, b1);
486         } else {
487             if (cnt == 0 && (m1 == NULL || l1 == 0))
488                 test_memory_null_empty(m1, '-');
489             else if (n1 > 0)
490                 test_printf_stderr("%04x:-%s\n", cnt, b1);
491             if (cnt == 0 && (m2 == NULL || l2 == 0))
492                 test_memory_null_empty(m2, '+');
493             else if (n2 > 0)
494                 test_printf_stderr("%04x:+%s\n", cnt, b2);
495             if (diff && i > 0)
496                 test_printf_stderr("% 4s  %s\n", "", bdiff);
497         }
498         m1 += n1;
499         m2 += n2;
500         l1 -= n1;
501         l2 -= n2;
502         cnt += bytes;
503     }
504 fin:
505     test_flush_stderr();
506 }
507
508 /*
509  * Wrapper routines so that the underlying code can be shared.
510  * The first is the call from inside the test utilities when a conditional
511  * fails.  The second is the user's call to dump memory.
512  */
513 void test_fail_memory_message(const char *prefix, const char *file,
514                               int line, const char *type,
515                               const char *left, const char *right,
516                               const char *op,
517                               const unsigned char *m1, size_t l1,
518                               const unsigned char *m2, size_t l2)
519 {
520     test_fail_memory_common(prefix, file, line, type, left, right, op,
521                             m1, l1, m2, l2);
522     test_printf_stderr("\n");
523 }
524
525 void test_output_memory(const char *name, const unsigned char *m, size_t l)
526 {
527     test_fail_memory_common("memory", NULL, 0, NULL, NULL, NULL, name,
528                             m, l, m, l);
529 }