| OLD | NEW | 
 | (Empty) | 
|    1 /* |  | 
|    2  * datatypes_driver.c |  | 
|    3  * |  | 
|    4  * a test driver for crypto/math datatypes |  | 
|    5  * |  | 
|    6  * David A. McGrew |  | 
|    7  * Cisco Systems, Inc. |  | 
|    8  */ |  | 
|    9  |  | 
|   10 /* |  | 
|   11  *       |  | 
|   12  * Copyright (c) 2001-2006, Cisco Systems, Inc. |  | 
|   13  * All rights reserved. |  | 
|   14  *  |  | 
|   15  * Redistribution and use in source and binary forms, with or without |  | 
|   16  * modification, are permitted provided that the following conditions |  | 
|   17  * are met: |  | 
|   18  *  |  | 
|   19  *   Redistributions of source code must retain the above copyright |  | 
|   20  *   notice, this list of conditions and the following disclaimer. |  | 
|   21  *  |  | 
|   22  *   Redistributions in binary form must reproduce the above |  | 
|   23  *   copyright notice, this list of conditions and the following |  | 
|   24  *   disclaimer in the documentation and/or other materials provided |  | 
|   25  *   with the distribution. |  | 
|   26  *  |  | 
|   27  *   Neither the name of the Cisco Systems, Inc. nor the names of its |  | 
|   28  *   contributors may be used to endorse or promote products derived |  | 
|   29  *   from this software without specific prior written permission. |  | 
|   30  *  |  | 
|   31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |  | 
|   32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |  | 
|   33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS |  | 
|   34  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE |  | 
|   35  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, |  | 
|   36  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |  | 
|   37  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |  | 
|   38  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |  | 
|   39  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |  | 
|   40  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |  | 
|   41  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |  | 
|   42  * OF THE POSSIBILITY OF SUCH DAMAGE. |  | 
|   43  * |  | 
|   44  */ |  | 
|   45  |  | 
|   46  |  | 
|   47 #ifdef HAVE_CONFIG_H |  | 
|   48     #include <config.h> |  | 
|   49 #endif |  | 
|   50  |  | 
|   51 #include <stdio.h>            /* for printf() */ |  | 
|   52 #include <string.h>           /* for strlen() */ |  | 
|   53 #include "datatypes.h" |  | 
|   54  |  | 
|   55 void |  | 
|   56 byte_order(void); |  | 
|   57  |  | 
|   58 void |  | 
|   59 test_hex_string_funcs(void); |  | 
|   60  |  | 
|   61 void |  | 
|   62 print_string(char *s); |  | 
|   63  |  | 
|   64 void |  | 
|   65 test_bswap(void); |  | 
|   66  |  | 
|   67 int |  | 
|   68 main (void) { |  | 
|   69    |  | 
|   70   /* |  | 
|   71    * this program includes various and sundry tests for fundamental |  | 
|   72    * datatypes.  it's a grab-bag of throwaway code, retained only in |  | 
|   73    * case of future problems |  | 
|   74    */ |  | 
|   75  |  | 
|   76   int i, j; |  | 
|   77   v128_t x; |  | 
|   78   char *r =  |  | 
|   79     "The Moving Finger writes; and, having writ,\n" |  | 
|   80     "Moves on: nor all thy Piety nor Wit\n" |  | 
|   81     "Shall lure it back to cancel half a Line,\n" |  | 
|   82     "Nor all thy Tears wash out a Word of it."; |  | 
|   83   char *s = "incomplet";  |  | 
|   84   |  | 
|   85   print_string(r); |  | 
|   86   print_string(s); |  | 
|   87   |  | 
|   88   byte_order(); |  | 
|   89   test_hex_string_funcs(); |  | 
|   90  |  | 
|   91   for (j=0; j < 128; j++) { |  | 
|   92     v128_set_to_zero(&x); |  | 
|   93     /*      x.v32[0] = (1 << j); */ |  | 
|   94     v128_set_bit(&x, j); |  | 
|   95     printf("%s\n", v128_bit_string(&x));  |  | 
|   96     v128_clear_bit(&x, j); |  | 
|   97     printf("%s\n", v128_bit_string(&x));  |  | 
|   98      |  | 
|   99   } |  | 
|  100  |  | 
|  101   printf("----------------------------------------------\n"); |  | 
|  102   v128_set_to_zero(&x); |  | 
|  103   for (i=0; i < 128; i++) { |  | 
|  104     v128_set_bit(&x, i); |  | 
|  105   } |  | 
|  106   printf("%s\n", v128_bit_string(&x));  |  | 
|  107  |  | 
|  108   printf("----------------------------------------------\n"); |  | 
|  109   v128_set_to_zero(&x); |  | 
|  110   v128_set_bit(&x, 0); |  | 
|  111   for (i=0; i < 128; i++) { |  | 
|  112       printf("%s\n", v128_bit_string(&x));  |  | 
|  113     v128_right_shift(&x, 1); |  | 
|  114   } |  | 
|  115   printf("----------------------------------------------\n"); |  | 
|  116   v128_set_to_zero(&x); |  | 
|  117   v128_set_bit(&x, 127); |  | 
|  118   for (i=0; i < 128; i++) { |  | 
|  119       printf("%s\n", v128_bit_string(&x));  |  | 
|  120     v128_left_shift(&x, 1); |  | 
|  121   } |  | 
|  122   printf("----------------------------------------------\n"); |  | 
|  123   for (i=0; i < 128; i++) { |  | 
|  124     v128_set_to_zero(&x); |  | 
|  125     v128_set_bit(&x, 127); |  | 
|  126     v128_left_shift(&x, i); |  | 
|  127       printf("%s\n", v128_bit_string(&x));  |  | 
|  128   } |  | 
|  129   printf("----------------------------------------------\n"); |  | 
|  130   v128_set_to_zero(&x); |  | 
|  131   for (i=0; i < 128; i+=2) { |  | 
|  132     v128_set_bit(&x, i); |  | 
|  133   } |  | 
|  134   printf("bit_string: { %s }\n", v128_bit_string(&x));  |  | 
|  135   printf("get_bit:    { ");    |  | 
|  136   for (i=0; i < 128; i++) { |  | 
|  137     if (v128_get_bit(&x, i) == 1) |  | 
|  138       printf("1"); |  | 
|  139     else |  | 
|  140       printf("0"); |  | 
|  141   } |  | 
|  142   printf(" } \n"); |  | 
|  143  |  | 
|  144   test_bswap(); |  | 
|  145  |  | 
|  146   return 0; |  | 
|  147 } |  | 
|  148  |  | 
|  149  |  | 
|  150 /* byte_order() prints out byte ordering of datatypes */ |  | 
|  151  |  | 
|  152 void |  | 
|  153 byte_order(void) { |  | 
|  154   int i; |  | 
|  155   v128_t e; |  | 
|  156 #if 0 |  | 
|  157   v16_t b; |  | 
|  158   v32_t c; |  | 
|  159   v64_t d; |  | 
|  160  |  | 
|  161   for (i=0; i < sizeof(b); i++) |  | 
|  162     b.octet[i] = i; |  | 
|  163   for (i=0; i < sizeof(c); i++) |  | 
|  164     c.octet[i] = i; |  | 
|  165   for (i=0; i < sizeof(d); i++) |  | 
|  166     d.octet[i] = i; |  | 
|  167    |  | 
|  168   printf("v128_t:\t%s\n", v128_hex_string(&e)); |  | 
|  169   printf("v64_t:\t%s\n", v64_hex_string(&d)); |  | 
|  170   printf("v32_t:\t%s\n", v32_hex_string(c)); |  | 
|  171   printf("v16_t:\t%s\n", v16_hex_string(b)); |  | 
|  172  |  | 
|  173   c.value = 0x01020304; |  | 
|  174   printf("v32_t:\t%s\n", v32_hex_string(c)); |  | 
|  175   b.value = 0x0102; |  | 
|  176   printf("v16_t:\t%s\n", v16_hex_string(b)); |  | 
|  177  |  | 
|  178   printf("uint16_t ordering:\n"); |  | 
|  179  |  | 
|  180   c.value = 0x00010002; |  | 
|  181   printf("v32_t:\t%x%x\n", c.v16[0], c.v16[1]); |  | 
|  182 #endif  |  | 
|  183  |  | 
|  184   printf("byte ordering of crypto/math datatypes:\n"); |  | 
|  185   for (i=0; i < sizeof(e); i++) |  | 
|  186     e.v8[i] = i; |  | 
|  187   printf("v128_t: %s\n", v128_hex_string(&e)); |  | 
|  188    |  | 
|  189 } |  | 
|  190  |  | 
|  191 void |  | 
|  192 test_hex_string_funcs(void) { |  | 
|  193   char hex1[] = "abadcafe"; |  | 
|  194   char hex2[] = "0123456789abcdefqqqqq"; |  | 
|  195   char raw[10]; |  | 
|  196   int len; |  | 
|  197  |  | 
|  198   len = hex_string_to_octet_string(raw, hex1, strlen(hex1)); |  | 
|  199   printf("computed length: %d\tstring: %s\n", len, |  | 
|  200          octet_string_hex_string(raw, len/2)); |  | 
|  201   printf("expected length: %u\tstring: %s\n", (unsigned)strlen(hex1), hex1); |  | 
|  202  |  | 
|  203   len = hex_string_to_octet_string(raw, hex2, strlen(hex2)); |  | 
|  204   printf("computed length: %d\tstring: %s\n", len, |  | 
|  205          octet_string_hex_string(raw, len/2)); |  | 
|  206   printf("expected length: %d\tstring: %s\n", 16, "0123456789abcdef"); |  | 
|  207  |  | 
|  208 } |  | 
|  209  |  | 
|  210 void |  | 
|  211 print_string(char *s) { |  | 
|  212   size_t i; |  | 
|  213   printf("%s\n", s); |  | 
|  214   printf("strlen(s) = %u\n", (unsigned)strlen(s)); |  | 
|  215   printf("{ "); |  | 
|  216   for (i=0; i < strlen(s); i++) { |  | 
|  217     printf("0x%x, ", s[i]); |  | 
|  218     if (((i+1) % 8) == 0) |  | 
|  219       printf("\n   "); |  | 
|  220   } |  | 
|  221   printf("}\n"); |  | 
|  222 } |  | 
|  223  |  | 
|  224 void |  | 
|  225 test_bswap(void) { |  | 
|  226   uint32_t x = 0x11223344; |  | 
|  227   uint64_t y = 0x1122334455667788LL; |  | 
|  228  |  | 
|  229   printf("before: %0x\nafter:  %0x\n", x, be32_to_cpu(x)); |  | 
|  230   printf("before: %0llx\nafter:  %0llx\n", (unsigned long long)y, |  | 
|  231          (unsigned long long)be64_to_cpu(y)); |  | 
|  232  |  | 
|  233   y = 1234; |  | 
|  234  |  | 
|  235   printf("1234: %0llx\n", (unsigned long long)y); |  | 
|  236   printf("as octet string: %s\n",  |  | 
|  237          octet_string_hex_string((uint8_t *) &y, 8)); |  | 
|  238   y = be64_to_cpu(y); |  | 
|  239   printf("bswapped octet string: %s\n",  |  | 
|  240          octet_string_hex_string((uint8_t *) &y, 8)); |  | 
|  241 } |  | 
| OLD | NEW |