/opensource.apple.com/source/OpenSSL096/OpenSSL096-15/openssl/crypto/md32_common.h

# · C++ Header · 632 lines · 431 code · 38 blank · 163 comment · 10 complexity · 7b6d99a351b1a615be11b48345d5f946 MD5 · raw file 

    

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    2. 

  2.     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
    3. 

  3. <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
    4. 

  4. <head>
    5. 

  5. <title>md32_common.h</title>
    6. 

  6. <style type="text/css">
    7. 

  7. .enscript-comment { font-style: italic; color: rgb(178,34,34); }
    8. 

  8. .enscript-function-name { font-weight: bold; color: rgb(0,0,255); }
    9. 

  9. .enscript-variable-name { font-weight: bold; color: rgb(184,134,11); }
    10. 

  10. .enscript-keyword { font-weight: bold; color: rgb(160,32,240); }
    11. 

  11. .enscript-reference { font-weight: bold; color: rgb(95,158,160); }
    12. 

  12. .enscript-string { font-weight: bold; color: rgb(188,143,143); }
    13. 

  13. .enscript-builtin { font-weight: bold; color: rgb(218,112,214); }
    14. 

  14. .enscript-type { font-weight: bold; color: rgb(34,139,34); }
    15. 

  15. .enscript-highlight { text-decoration: underline; color: 0; }
    16. 

  16. </style>
    17. 

  17. </head>
    18. 

  18. <body id="top">
    19. 

  19. <h1 style="margin:8px;" id="f1">md32_common.h&nbsp;&nbsp;&nbsp;<span style="font-weight: normal; font-size: 0.5em;">[<a href="?txt">plain text</a>]</span></h1>
    20. 

  20. <hr/>
    21. 

  21. <div></div>
    22. 

  22. <pre>
    23. 

  23. <span class="enscript-comment">/* crypto/md32_common.h */</span>
    24. 

  24. <span class="enscript-comment">/* ====================================================================
    25. 

  25.  * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
    26. 

  26.  *
    27. 

  27.  * Redistribution and use in source and binary forms, with or without
    28. 

  28.  * modification, are permitted provided that the following conditions
    29. 

  29.  * are met:
    30. 

  30.  *
    31. 

  31.  * 1. Redistributions of source code must retain the above copyright
    32. 

  32.  *    notice, this list of conditions and the following disclaimer. 
    33. 

  33.  *
    34. 

  34.  * 2. Redistributions in binary form must reproduce the above copyright
    35. 

  35.  *    notice, this list of conditions and the following disclaimer in
    36. 

  36.  *    the documentation and/or other materials provided with the
    37. 

  37.  *    distribution.
    38. 

  38.  *
    39. 

  39.  * 3. All advertising materials mentioning features or use of this
    40. 

  40.  *    software must display the following acknowledgment:
    41. 

  41.  *    &quot;This product includes software developed by the OpenSSL Project
    42. 

  42.  *    for use in the OpenSSL Toolkit. (<a href="http://www.OpenSSL.org/">http://www.OpenSSL.org/</a>)&quot;
    43. 

  43.  *
    44. 

  44.  * 4. The names &quot;OpenSSL Toolkit&quot; and &quot;OpenSSL Project&quot; must not be used to
    45. 

  45.  *    endorse or promote products derived from this software without
    46. 

  46.  *    prior written permission. For written permission, please contact
    47. 

  47.  *    <a href="mailto:licensing@OpenSSL.org">licensing@OpenSSL.org</a>.
    48. 

  48.  *
    49. 

  49.  * 5. Products derived from this software may not be called &quot;OpenSSL&quot;
    50. 

  50.  *    nor may &quot;OpenSSL&quot; appear in their names without prior written
    51. 

  51.  *    permission of the OpenSSL Project.
    52. 

  52.  *
    53. 

  53.  * 6. Redistributions of any form whatsoever must retain the following
    54. 

  54.  *    acknowledgment:
    55. 

  55.  *    &quot;This product includes software developed by the OpenSSL Project
    56. 

  56.  *    for use in the OpenSSL Toolkit (<a href="http://www.OpenSSL.org/">http://www.OpenSSL.org/</a>)&quot;
    57. 

  57.  *
    58. 

  58.  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
    59. 

  59.  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    60. 

  60.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
    61. 

  61.  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
    62. 

  62.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    63. 

  63.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
    64. 

  64.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
    65. 

  65.  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    66. 

  66.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
    67. 

  67.  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    68. 

  68.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
    69. 

  69.  * OF THE POSSIBILITY OF SUCH DAMAGE.
    70. 

  70.  * ====================================================================
    71. 

  71.  *
    72. 

  72.  * This product includes cryptographic software written by Eric Young
    73. 

  73.  * (<a href="mailto:eay@cryptsoft.com">eay@cryptsoft.com</a>).  This product includes software written by Tim
    74. 

  74.  * Hudson (<a href="mailto:tjh@cryptsoft.com">tjh@cryptsoft.com</a>).
    75. 

  75.  *
    76. 

  76.  */</span>
    77. 

  77. 

  78. <span class="enscript-comment">/*
    79. 

  79.  * This is a generic 32 bit &quot;collector&quot; for message digest algorithms.
    80. 

  80.  * Whenever needed it collects input character stream into chunks of
    81. 

  81.  * 32 bit values and invokes a block function that performs actual hash
    82. 

  82.  * calculations.
    83. 

  83.  *
    84. 

  84.  * Porting guide.
    85. 

  85.  *
    86. 

  86.  * Obligatory macros:
    87. 

  87.  *
    88. 

  88.  * DATA_ORDER_IS_BIG_ENDIAN or DATA_ORDER_IS_LITTLE_ENDIAN
    89. 

  89.  *	this macro defines byte order of input stream.
    90. 

  90.  * HASH_CBLOCK
    91. 

  91.  *	size of a unit chunk HASH_BLOCK operates on.
    92. 

  92.  * HASH_LONG
    93. 

  93.  *	has to be at lest 32 bit wide, if it's wider, then
    94. 

  94.  *	HASH_LONG_LOG2 *has to* be defined along
    95. 

  95.  * HASH_CTX
    96. 

  96.  *	context structure that at least contains following
    97. 

  97.  *	members:
    98. 

  98.  *		typedef struct {
    99. 

  99.  *			...
    100. 

  100.  *			HASH_LONG	Nl,Nh;
    101. 

  101.  *			HASH_LONG	data[HASH_LBLOCK];
    102. 

  102.  *			int		num;
    103. 

  103.  *			...
    104. 

  104.  *			} HASH_CTX;
    105. 

  105.  * HASH_UPDATE
    106. 

  106.  *	name of &quot;Update&quot; function, implemented here.
    107. 

  107.  * HASH_TRANSFORM
    108. 

  108.  *	name of &quot;Transform&quot; function, implemented here.
    109. 

  109.  * HASH_FINAL
    110. 

  110.  *	name of &quot;Final&quot; function, implemented here.
    111. 

  111.  * HASH_BLOCK_HOST_ORDER
    112. 

  112.  *	name of &quot;block&quot; function treating *aligned* input message
    113. 

  113.  *	in host byte order, implemented externally.
    114. 

  114.  * HASH_BLOCK_DATA_ORDER
    115. 

  115.  *	name of &quot;block&quot; function treating *unaligned* input message
    116. 

  116.  *	in original (data) byte order, implemented externally (it
    117. 

  117.  *	actually is optional if data and host are of the same
    118. 

  118.  *	&quot;endianess&quot;).
    119. 

  119.  * HASH_MAKE_STRING
    120. 

  120.  *	macro convering context variables to an ASCII hash string.
    121. 

  121.  *
    122. 

  122.  * Optional macros:
    123. 

  123.  *
    124. 

  124.  * B_ENDIAN or L_ENDIAN
    125. 

  125.  *	defines host byte-order.
    126. 

  126.  * HASH_LONG_LOG2
    127. 

  127.  *	defaults to 2 if not states otherwise.
    128. 

  128.  * HASH_LBLOCK
    129. 

  129.  *	assumed to be HASH_CBLOCK/4 if not stated otherwise.
    130. 

  130.  * HASH_BLOCK_DATA_ORDER_ALIGNED
    131. 

  131.  *	alternative &quot;block&quot; function capable of treating
    132. 

  132.  *	aligned input message in original (data) order,
    133. 

  133.  *	implemented externally.
    134. 

  134.  *
    135. 

  135.  * MD5 example:
    136. 

  136.  *
    137. 

  137.  *	#define DATA_ORDER_IS_LITTLE_ENDIAN
    138. 

  138.  *
    139. 

  139.  *	#define HASH_LONG		MD5_LONG
    140. 

  140.  *	#define HASH_LONG_LOG2		MD5_LONG_LOG2
    141. 

  141.  *	#define HASH_CTX		MD5_CTX
    142. 

  142.  *	#define HASH_CBLOCK		MD5_CBLOCK
    143. 

  143.  *	#define HASH_LBLOCK		MD5_LBLOCK
    144. 

  144.  *	#define HASH_UPDATE		MD5_Update
    145. 

  145.  *	#define HASH_TRANSFORM		MD5_Transform
    146. 

  146.  *	#define HASH_FINAL		MD5_Final
    147. 

  147.  *	#define HASH_BLOCK_HOST_ORDER	md5_block_host_order
    148. 

  148.  *	#define HASH_BLOCK_DATA_ORDER	md5_block_data_order
    149. 

  149.  *
    150. 

  150.  *					&lt;<a href="mailto:appro@fy.chalmers.se">appro@fy.chalmers.se</a>&gt;
    151. 

  151.  */</span>
    152. 

  152. 

  153. #<span class="enscript-reference">if</span> !<span class="enscript-reference">defined</span>(<span class="enscript-variable-name">DATA_ORDER_IS_BIG_ENDIAN</span>) &amp;&amp; !<span class="enscript-reference">defined</span>(<span class="enscript-variable-name">DATA_ORDER_IS_LITTLE_ENDIAN</span>)
    154. 

  154. #<span class="enscript-reference">error</span> <span class="enscript-string">&quot;DATA_ORDER must be defined!&quot;</span>
    155. 

  155. #<span class="enscript-reference">endif</span>
    156. 

  156. 

  157. #<span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">HASH_CBLOCK</span>
    158. 

  158. #<span class="enscript-reference">error</span> <span class="enscript-string">&quot;HASH_CBLOCK must be defined!&quot;</span>
    159. 

  159. #<span class="enscript-reference">endif</span>
    160. 

  160. #<span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">HASH_LONG</span>
    161. 

  161. #<span class="enscript-reference">error</span> <span class="enscript-string">&quot;HASH_LONG must be defined!&quot;</span>
    162. 

  162. #<span class="enscript-reference">endif</span>
    163. 

  163. #<span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">HASH_CTX</span>
    164. 

  164. #<span class="enscript-reference">error</span> <span class="enscript-string">&quot;HASH_CTX must be defined!&quot;</span>
    165. 

  165. #<span class="enscript-reference">endif</span>
    166. 

  166. 

  167. #<span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">HASH_UPDATE</span>
    168. 

  168. #<span class="enscript-reference">error</span> <span class="enscript-string">&quot;HASH_UPDATE must be defined!&quot;</span>
    169. 

  169. #<span class="enscript-reference">endif</span>
    170. 

  170. #<span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">HASH_TRANSFORM</span>
    171. 

  171. #<span class="enscript-reference">error</span> <span class="enscript-string">&quot;HASH_TRANSFORM must be defined!&quot;</span>
    172. 

  172. #<span class="enscript-reference">endif</span>
    173. 

  173. #<span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">HASH_FINAL</span>
    174. 

  174. #<span class="enscript-reference">error</span> <span class="enscript-string">&quot;HASH_FINAL must be defined!&quot;</span>
    175. 

  175. #<span class="enscript-reference">endif</span>
    176. 

  176. 

  177. #<span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">HASH_BLOCK_HOST_ORDER</span>
    178. 

  178. #<span class="enscript-reference">error</span> <span class="enscript-string">&quot;HASH_BLOCK_HOST_ORDER must be defined!&quot;</span>
    179. 

  179. #<span class="enscript-reference">endif</span>
    180. 

  180. 

  181. #<span class="enscript-reference">if</span> 0
    182. 

  182. <span class="enscript-comment">/*
    183. 

  183.  * Moved below as it's required only if HASH_BLOCK_DATA_ORDER_ALIGNED
    184. 

  184.  * isn't defined.
    185. 

  185.  */</span>
    186. 

  186. #<span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">HASH_BLOCK_DATA_ORDER</span>
    187. 

  187. #<span class="enscript-reference">error</span> <span class="enscript-string">&quot;HASH_BLOCK_DATA_ORDER must be defined!&quot;</span>
    188. 

  188. #<span class="enscript-reference">endif</span>
    189. 

  189. #<span class="enscript-reference">endif</span>
    190. 

  190. 

  191. #<span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">HASH_LBLOCK</span>
    192. 

  192. #<span class="enscript-reference">define</span> <span class="enscript-variable-name">HASH_LBLOCK</span>	(HASH_CBLOCK/4)
    193. 

  193. #<span class="enscript-reference">endif</span>
    194. 

  194. 

  195. #<span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">HASH_LONG_LOG2</span>
    196. 

  196. #<span class="enscript-reference">define</span> <span class="enscript-variable-name">HASH_LONG_LOG2</span>	2
    197. 

  197. #<span class="enscript-reference">endif</span>
    198. 

  198. 

  199. <span class="enscript-comment">/*
    200. 

  200.  * Engage compiler specific rotate intrinsic function if available.
    201. 

  201.  */</span>
    202. 

  202. #<span class="enscript-reference">undef</span> <span class="enscript-variable-name">ROTATE</span>
    203. 

  203. #<span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">PEDANTIC</span>
    204. 

  204. # <span class="enscript-reference">if</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">_MSC_VER</span>)
    205. 

  205. #  <span class="enscript-reference">define</span> <span class="enscript-function-name">ROTATE</span>(a,n)	_lrotl(a,n)
    206. 

  206. # <span class="enscript-reference">elif</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">__MWERKS__</span>)
    207. 

  207. #  <span class="enscript-reference">if</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">__POWERPC__</span>)
    208. 

  208. #   <span class="enscript-reference">define</span> <span class="enscript-function-name">ROTATE</span>(a,n)	__rlwinm(a,n,0,31)
    209. 

  209. #  <span class="enscript-reference">elif</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">__MC68K__</span>)
    210. 

  210.     <span class="enscript-comment">/* Motorola specific tweak. &lt;<a href="mailto:appro@fy.chalmers.se">appro@fy.chalmers.se</a>&gt; */</span>
    211. 

  211. #   <span class="enscript-reference">define</span> <span class="enscript-function-name">ROTATE</span>(a,n)	( n&lt;24 ? __rol(a,n) : __ror(a,32-n) )
    212. 

  212. #  <span class="enscript-reference">else</span>
    213. 

  213. #   <span class="enscript-reference">define</span> <span class="enscript-function-name">ROTATE</span>(a,n)	__rol(a,n)
    214. 

  214. #  <span class="enscript-reference">endif</span>
    215. 

  215. # <span class="enscript-reference">elif</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">__GNUC__</span>) &amp;&amp; <span class="enscript-variable-name">__GNUC__</span>&gt;=2 &amp;&amp; !<span class="enscript-reference">defined</span>(<span class="enscript-variable-name">NO_ASM</span>) &amp;&amp; !<span class="enscript-reference">defined</span>(<span class="enscript-variable-name">NO_INLINE_ASM</span>)
    216. 

  216.   <span class="enscript-comment">/*
    217. 

  217.    * Some GNU C inline assembler templates. Note that these are
    218. 

  218.    * rotates by *constant* number of bits! But that's exactly
    219. 

  219.    * what we need here...
    220. 

  220.    *
    221. 

  221.    * 					&lt;<a href="mailto:appro@fy.chalmers.se">appro@fy.chalmers.se</a>&gt;
    222. 

  222.    */</span>
    223. 

  223. #  <span class="enscript-reference">if</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">__i386</span>) || <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">__i386__</span>)
    224. 

  224. #   <span class="enscript-reference">define</span> <span class="enscript-function-name">ROTATE</span>(a,n)	({ register unsigned int ret;	\
    225. 

  225. 				asm (			\
    226. 

  226. 				<span class="enscript-string">&quot;roll %1,%0&quot;</span>		\
    227. 

  227. 				: <span class="enscript-string">&quot;=r&quot;</span>(ret)		\
    228. 

  228. 				: <span class="enscript-string">&quot;I&quot;</span>(n), <span class="enscript-string">&quot;0&quot;</span>(a)	\
    229. 

  229. 				: <span class="enscript-string">&quot;cc&quot;</span>);		\
    230. 

  230. 			   ret;				\
    231. 

  231. 			})
    232. 

  232. #  <span class="enscript-reference">elif</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">__powerpc</span>) || <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">__ppc</span>)
    233. 

  233. #   <span class="enscript-reference">define</span> <span class="enscript-function-name">ROTATE</span>(a,n)	({ register unsigned int ret;	\
    234. 

  234. 				asm (			\
    235. 

  235. 				<span class="enscript-string">&quot;rlwinm %0,%1,%2,0,31&quot;</span>	\
    236. 

  236. 				: <span class="enscript-string">&quot;=r&quot;</span>(ret)		\
    237. 

  237. 				: <span class="enscript-string">&quot;r&quot;</span>(a), <span class="enscript-string">&quot;I&quot;</span>(n));	\
    238. 

  238. 			   ret;				\
    239. 

  239. 			})
    240. 

  240. #  <span class="enscript-reference">endif</span>
    241. 

  241. # <span class="enscript-reference">endif</span>
    242. 

  242. 

  243. <span class="enscript-comment">/*
    244. 

  244.  * Engage compiler specific &quot;fetch in reverse byte order&quot;
    245. 

  245.  * intrinsic function if available.
    246. 

  246.  */</span>
    247. 

  247. # <span class="enscript-reference">if</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">__GNUC__</span>) &amp;&amp; <span class="enscript-variable-name">__GNUC__</span>&gt;=2 &amp;&amp; !<span class="enscript-reference">defined</span>(<span class="enscript-variable-name">NO_ASM</span>) &amp;&amp; !<span class="enscript-reference">defined</span>(<span class="enscript-variable-name">NO_INLINE_ASM</span>)
    248. 

  248.   <span class="enscript-comment">/* some GNU C inline assembler templates by &lt;<a href="mailto:appro@fy.chalmers.se">appro@fy.chalmers.se</a>&gt; */</span>
    249. 

  249. #  <span class="enscript-reference">if</span> (<span class="enscript-reference">defined</span>(<span class="enscript-variable-name">__i386</span>) || <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">__i386__</span>)) &amp;&amp; !<span class="enscript-reference">defined</span>(<span class="enscript-variable-name">I386_ONLY</span>)
    250. 

  250. #   <span class="enscript-reference">define</span> <span class="enscript-function-name">BE_FETCH32</span>(a)	({ register unsigned int l=(a);\
    251. 

  251. 				asm (			\
    252. 

  252. 				<span class="enscript-string">&quot;bswapl %0&quot;</span>		\
    253. 

  253. 				: <span class="enscript-string">&quot;=r&quot;</span>(l) : <span class="enscript-string">&quot;0&quot;</span>(l));	\
    254. 

  254. 			  l;				\
    255. 

  255. 			})
    256. 

  256. #  <span class="enscript-reference">elif</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">__powerpc</span>)
    257. 

  257. #   <span class="enscript-reference">define</span> <span class="enscript-function-name">LE_FETCH32</span>(a)	({ register unsigned int l;	\
    258. 

  258. 				asm (			\
    259. 

  259. 				<span class="enscript-string">&quot;lwbrx %0,0,%1&quot;</span>		\
    260. 

  260. 				: <span class="enscript-string">&quot;=r&quot;</span>(l)		\
    261. 

  261. 				: <span class="enscript-string">&quot;r&quot;</span>(a));		\
    262. 

  262. 			   l;				\
    263. 

  263. 			})
    264. 

  264. 

  265. #  <span class="enscript-reference">elif</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">__sparc</span>) &amp;&amp; <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">ULTRASPARC</span>)
    266. 

  266. #  <span class="enscript-reference">define</span> <span class="enscript-function-name">LE_FETCH32</span>(a)	({ register unsigned int l;		\
    267. 

  267. 				asm (				\
    268. 

  268. 				<span class="enscript-string">&quot;lda [%1]#ASI_PRIMARY_LITTLE,%0&quot;</span>\
    269. 

  269. 				: <span class="enscript-string">&quot;=r&quot;</span>(l)			\
    270. 

  270. 				: <span class="enscript-string">&quot;r&quot;</span>(a));			\
    271. 

  271. 			   l;					\
    272. 

  272. 			})
    273. 

  273. #  <span class="enscript-reference">endif</span>
    274. 

  274. # <span class="enscript-reference">endif</span>
    275. 

  275. #<span class="enscript-reference">endif</span> <span class="enscript-comment">/* PEDANTIC */</span>
    276. 

  276. 

  277. #<span class="enscript-reference">if</span> <span class="enscript-variable-name">HASH_LONG_LOG2</span>==2	<span class="enscript-comment">/* Engage only if sizeof(HASH_LONG)== 4 */</span>
    278. 

  278. <span class="enscript-comment">/* A nice byte order reversal from Wei Dai &lt;<a href="mailto:weidai@eskimo.com">weidai@eskimo.com</a>&gt; */</span>
    279. 

  279. #<span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">ROTATE</span>
    280. 

  280. <span class="enscript-comment">/* 5 instructions with rotate instruction, else 9 */</span>
    281. 

  281. #<span class="enscript-reference">define</span> <span class="enscript-function-name">REVERSE_FETCH32</span>(a,l)	(					\
    282. 

  282. 		l=*(<span class="enscript-type">const</span> HASH_LONG *)(a),				\
    283. 

  283. 		((ROTATE(l,8)&amp;0x00FF00FF)|(ROTATE((l&amp;0x00FF00FF),24)))	\
    284. 

  284. 				)
    285. 

  285. #<span class="enscript-reference">else</span>
    286. 

  286. <span class="enscript-comment">/* 6 instructions with rotate instruction, else 8 */</span>
    287. 

  287. #<span class="enscript-reference">define</span> <span class="enscript-function-name">REVERSE_FETCH32</span>(a,l)	(				\
    288. 

  288. 		l=*(<span class="enscript-type">const</span> HASH_LONG *)(a),			\
    289. 

  289. 		l=(((l&gt;&gt;8)&amp;0x00FF00FF)|((l&amp;0x00FF00FF)&lt;&lt;8)),	\
    290. 

  290. 		ROTATE(l,16)					\
    291. 

  291. 				)
    292. 

  292. <span class="enscript-comment">/*
    293. 

  293.  * Originally the middle line started with l=(((l&amp;0xFF00FF00)&gt;&gt;8)|...
    294. 

  294.  * It's rewritten as above for two reasons:
    295. 

  295.  *	- RISCs aren't good at long constants and have to explicitely
    296. 

  296.  *	  compose 'em with several (well, usually 2) instructions in a
    297. 

  297.  *	  register before performing the actual operation and (as you
    298. 

  298.  *	  already realized:-) having same constant should inspire the
    299. 

  299.  *	  compiler to permanently allocate the only register for it;
    300. 

  300.  *	- most modern CPUs have two ALUs, but usually only one has
    301. 

  301.  *	  circuitry for shifts:-( this minor tweak inspires compiler
    302. 

  302.  *	  to schedule shift instructions in a better way...
    303. 

  303.  *
    304. 

  304.  *				&lt;<a href="mailto:appro@fy.chalmers.se">appro@fy.chalmers.se</a>&gt;
    305. 

  305.  */</span>
    306. 

  306. #<span class="enscript-reference">endif</span>
    307. 

  307. #<span class="enscript-reference">endif</span>
    308. 

  308. 

  309. #<span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">ROTATE</span>
    310. 

  310. #<span class="enscript-reference">define</span> <span class="enscript-function-name">ROTATE</span>(a,n)     (((a)&lt;&lt;(n))|(((a)&amp;0xffffffff)&gt;&gt;(32-(n))))
    311. 

  311. #<span class="enscript-reference">endif</span>
    312. 

  312. 

  313. <span class="enscript-comment">/*
    314. 

  314.  * Make some obvious choices. E.g., HASH_BLOCK_DATA_ORDER_ALIGNED
    315. 

  315.  * and HASH_BLOCK_HOST_ORDER ought to be the same if input data
    316. 

  316.  * and host are of the same &quot;endianess&quot;. It's possible to mask
    317. 

  317.  * this with blank #define HASH_BLOCK_DATA_ORDER though...
    318. 

  318.  *
    319. 

  319.  *				&lt;<a href="mailto:appro@fy.chalmers.se">appro@fy.chalmers.se</a>&gt;
    320. 

  320.  */</span>
    321. 

  321. #<span class="enscript-reference">if</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">B_ENDIAN</span>)
    322. 

  322. #  <span class="enscript-reference">if</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">DATA_ORDER_IS_BIG_ENDIAN</span>)
    323. 

  323. #    <span class="enscript-reference">if</span> !<span class="enscript-reference">defined</span>(<span class="enscript-variable-name">HASH_BLOCK_DATA_ORDER_ALIGNED</span>) &amp;&amp; <span class="enscript-variable-name">HASH_LONG_LOG2</span>==2
    324. 

  324. #      <span class="enscript-reference">define</span> <span class="enscript-variable-name">HASH_BLOCK_DATA_ORDER_ALIGNED</span>	HASH_BLOCK_HOST_ORDER
    325. 

  325. #    <span class="enscript-reference">endif</span>
    326. 

  326. #  <span class="enscript-reference">elif</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">DATA_ORDER_IS_LITTLE_ENDIAN</span>)
    327. 

  327. #    <span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">HOST_FETCH32</span>
    328. 

  328. #      <span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">LE_FETCH32</span>
    329. 

  329. #        <span class="enscript-reference">define</span> <span class="enscript-function-name">HOST_FETCH32</span>(p,l)	LE_FETCH32(p)
    330. 

  330. #      <span class="enscript-reference">elif</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">REVERSE_FETCH32</span>)
    331. 

  331. #        <span class="enscript-reference">define</span> <span class="enscript-function-name">HOST_FETCH32</span>(p,l)	REVERSE_FETCH32(p,l)
    332. 

  332. #      <span class="enscript-reference">endif</span>
    333. 

  333. #    <span class="enscript-reference">endif</span>
    334. 

  334. #  <span class="enscript-reference">endif</span>
    335. 

  335. #<span class="enscript-reference">elif</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">L_ENDIAN</span>)
    336. 

  336. #  <span class="enscript-reference">if</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">DATA_ORDER_IS_LITTLE_ENDIAN</span>)
    337. 

  337. #    <span class="enscript-reference">if</span> !<span class="enscript-reference">defined</span>(<span class="enscript-variable-name">HASH_BLOCK_DATA_ORDER_ALIGNED</span>) &amp;&amp; <span class="enscript-variable-name">HASH_LONG_LOG2</span>==2
    338. 

  338. #      <span class="enscript-reference">define</span> <span class="enscript-variable-name">HASH_BLOCK_DATA_ORDER_ALIGNED</span>	HASH_BLOCK_HOST_ORDER
    339. 

  339. #    <span class="enscript-reference">endif</span>
    340. 

  340. #  <span class="enscript-reference">elif</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">DATA_ORDER_IS_BIG_ENDIAN</span>)
    341. 

  341. #    <span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">HOST_FETCH32</span>
    342. 

  342. #      <span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">BE_FETCH32</span>
    343. 

  343. #        <span class="enscript-reference">define</span> <span class="enscript-function-name">HOST_FETCH32</span>(p,l)	BE_FETCH32(p)
    344. 

  344. #      <span class="enscript-reference">elif</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">REVERSE_FETCH32</span>)
    345. 

  345. #        <span class="enscript-reference">define</span> <span class="enscript-function-name">HOST_FETCH32</span>(p,l)	REVERSE_FETCH32(p,l)
    346. 

  346. #      <span class="enscript-reference">endif</span>
    347. 

  347. #    <span class="enscript-reference">endif</span>
    348. 

  348. #  <span class="enscript-reference">endif</span>
    349. 

  349. #<span class="enscript-reference">endif</span>
    350. 

  350. 

  351. #<span class="enscript-reference">if</span> !<span class="enscript-reference">defined</span>(<span class="enscript-variable-name">HASH_BLOCK_DATA_ORDER_ALIGNED</span>)
    352. 

  352. #<span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">HASH_BLOCK_DATA_ORDER</span>
    353. 

  353. #<span class="enscript-reference">error</span> <span class="enscript-string">&quot;HASH_BLOCK_DATA_ORDER must be defined!&quot;</span>
    354. 

  354. #<span class="enscript-reference">endif</span>
    355. 

  355. #<span class="enscript-reference">endif</span>
    356. 

  356. 

  357. #<span class="enscript-reference">if</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">DATA_ORDER_IS_BIG_ENDIAN</span>)
    358. 

  358. 

  359. #<span class="enscript-reference">define</span> <span class="enscript-function-name">HOST_c2l</span>(c,l)	(l =(((unsigned long)(*((c)++)))&lt;&lt;24),		\
    360. 

  360. 			 l|=(((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*((c)++)))&lt;&lt;16),		\
    361. 

  361. 			 l|=(((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*((c)++)))&lt;&lt; 8),		\
    362. 

  362. 			 l|=(((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*((c)++)))    ),		\
    363. 

  363. 			 l)
    364. 

  364. #<span class="enscript-reference">define</span> <span class="enscript-function-name">HOST_p_c2l</span>(c,l,n)	{					\
    365. 

  365. 			<span class="enscript-keyword">switch</span> (n) {					\
    366. 

  366. 			<span class="enscript-keyword">case</span> <span class="enscript-reference">0</span>: l =((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*((c)++)))&lt;&lt;24;	\
    367. 

  367. 			<span class="enscript-keyword">case</span> <span class="enscript-reference">1</span>: l|=((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*((c)++)))&lt;&lt;16;	\
    368. 

  368. 			<span class="enscript-keyword">case</span> <span class="enscript-reference">2</span>: l|=((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*((c)++)))&lt;&lt; 8;	\
    369. 

  369. 			<span class="enscript-keyword">case</span> <span class="enscript-reference">3</span>: l|=((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*((c)++)));		\
    370. 

  370. 				} }
    371. 

  371. #<span class="enscript-reference">define</span> <span class="enscript-function-name">HOST_p_c2l_p</span>(c,l,sc,len) {					\
    372. 

  372. 			<span class="enscript-keyword">switch</span> (sc) {					\
    373. 

  373. 			<span class="enscript-keyword">case</span> <span class="enscript-reference">0</span>: l =((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*((c)++)))&lt;&lt;24;	\
    374. 

  374. 				<span class="enscript-keyword">if</span> (--len == 0) <span class="enscript-keyword">break</span>;			\
    375. 

  375. 			<span class="enscript-keyword">case</span> <span class="enscript-reference">1</span>: l|=((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*((c)++)))&lt;&lt;16;	\
    376. 

  376. 				<span class="enscript-keyword">if</span> (--len == 0) <span class="enscript-keyword">break</span>;			\
    377. 

  377. 			<span class="enscript-keyword">case</span> <span class="enscript-reference">2</span>: l|=((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*((c)++)))&lt;&lt; 8;	\
    378. 

  378. 				} }
    379. 

  379. <span class="enscript-comment">/* NOTE the pointer is not incremented at the end of this */</span>
    380. 

  380. #<span class="enscript-reference">define</span> <span class="enscript-function-name">HOST_c2l_p</span>(c,l,n)	{					\
    381. 

  381. 			l=0; (c)+=n;					\
    382. 

  382. 			<span class="enscript-keyword">switch</span> (n) {					\
    383. 

  383. 			<span class="enscript-keyword">case</span> <span class="enscript-reference">3</span>: l =((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*(--(c))))&lt;&lt; 8;	\
    384. 

  384. 			<span class="enscript-keyword">case</span> <span class="enscript-reference">2</span>: l|=((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*(--(c))))&lt;&lt;16;	\
    385. 

  385. 			<span class="enscript-keyword">case</span> <span class="enscript-reference">1</span>: l|=((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*(--(c))))&lt;&lt;24;	\
    386. 

  386. 				} }
    387. 

  387. #<span class="enscript-reference">define</span> <span class="enscript-function-name">HOST_l2c</span>(l,c)	(*((c)++)=(unsigned char)(((l)&gt;&gt;24)&amp;0xff),	\
    388. 

  388. 			 *((c)++)=(<span class="enscript-type">unsigned</span> <span class="enscript-type">char</span>)(((l)&gt;&gt;16)&amp;0xff),	\
    389. 

  389. 			 *((c)++)=(<span class="enscript-type">unsigned</span> <span class="enscript-type">char</span>)(((l)&gt;&gt; 8)&amp;0xff),	\
    390. 

  390. 			 *((c)++)=(<span class="enscript-type">unsigned</span> <span class="enscript-type">char</span>)(((l)    )&amp;0xff),	\
    391. 

  391. 			 l)
    392. 

  392. 

  393. #<span class="enscript-reference">elif</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">DATA_ORDER_IS_LITTLE_ENDIAN</span>)
    394. 

  394. 

  395. #<span class="enscript-reference">define</span> <span class="enscript-function-name">HOST_c2l</span>(c,l)	(l =(((unsigned long)(*((c)++)))    ),		\
    396. 

  396. 			 l|=(((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*((c)++)))&lt;&lt; 8),		\
    397. 

  397. 			 l|=(((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*((c)++)))&lt;&lt;16),		\
    398. 

  398. 			 l|=(((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*((c)++)))&lt;&lt;24),		\
    399. 

  399. 			 l)
    400. 

  400. #<span class="enscript-reference">define</span> <span class="enscript-function-name">HOST_p_c2l</span>(c,l,n)	{					\
    401. 

  401. 			<span class="enscript-keyword">switch</span> (n) {					\
    402. 

  402. 			<span class="enscript-keyword">case</span> <span class="enscript-reference">0</span>: l =((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*((c)++)));		\
    403. 

  403. 			<span class="enscript-keyword">case</span> <span class="enscript-reference">1</span>: l|=((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*((c)++)))&lt;&lt; 8;	\
    404. 

  404. 			<span class="enscript-keyword">case</span> <span class="enscript-reference">2</span>: l|=((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*((c)++)))&lt;&lt;16;	\
    405. 

  405. 			<span class="enscript-keyword">case</span> <span class="enscript-reference">3</span>: l|=((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*((c)++)))&lt;&lt;24;	\
    406. 

  406. 				} }
    407. 

  407. #<span class="enscript-reference">define</span> <span class="enscript-function-name">HOST_p_c2l_p</span>(c,l,sc,len) {					\
    408. 

  408. 			<span class="enscript-keyword">switch</span> (sc) {					\
    409. 

  409. 			<span class="enscript-keyword">case</span> <span class="enscript-reference">0</span>: l =((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*((c)++)));		\
    410. 

  410. 				<span class="enscript-keyword">if</span> (--len == 0) <span class="enscript-keyword">break</span>;			\
    411. 

  411. 			<span class="enscript-keyword">case</span> <span class="enscript-reference">1</span>: l|=((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*((c)++)))&lt;&lt; 8;	\
    412. 

  412. 				<span class="enscript-keyword">if</span> (--len == 0) <span class="enscript-keyword">break</span>;			\
    413. 

  413. 			<span class="enscript-keyword">case</span> <span class="enscript-reference">2</span>: l|=((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*((c)++)))&lt;&lt;16;	\
    414. 

  414. 				} }
    415. 

  415. <span class="enscript-comment">/* NOTE the pointer is not incremented at the end of this */</span>
    416. 

  416. #<span class="enscript-reference">define</span> <span class="enscript-function-name">HOST_c2l_p</span>(c,l,n)	{					\
    417. 

  417. 			l=0; (c)+=n;					\
    418. 

  418. 			<span class="enscript-keyword">switch</span> (n) {					\
    419. 

  419. 			<span class="enscript-keyword">case</span> <span class="enscript-reference">3</span>: l =((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*(--(c))))&lt;&lt;16;	\
    420. 

  420. 			<span class="enscript-keyword">case</span> <span class="enscript-reference">2</span>: l|=((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*(--(c))))&lt;&lt; 8;	\
    421. 

  421. 			<span class="enscript-keyword">case</span> <span class="enscript-reference">1</span>: l|=((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)(*(--(c))));		\
    422. 

  422. 				} }
    423. 

  423. #<span class="enscript-reference">define</span> <span class="enscript-function-name">HOST_l2c</span>(l,c)	(*((c)++)=(unsigned char)(((l)    )&amp;0xff),	\
    424. 

  424. 			 *((c)++)=(<span class="enscript-type">unsigned</span> <span class="enscript-type">char</span>)(((l)&gt;&gt; 8)&amp;0xff),	\
    425. 

  425. 			 *((c)++)=(<span class="enscript-type">unsigned</span> <span class="enscript-type">char</span>)(((l)&gt;&gt;16)&amp;0xff),	\
    426. 

  426. 			 *((c)++)=(<span class="enscript-type">unsigned</span> <span class="enscript-type">char</span>)(((l)&gt;&gt;24)&amp;0xff),	\
    427. 

  427. 			 l)
    428. 

  428. 

  429. #<span class="enscript-reference">endif</span>
    430. 

  430. 

  431. <span class="enscript-comment">/*
    432. 

  432.  * Time for some action:-)
    433. 

  433.  */</span>
    434. 

  434. 

  435. <span class="enscript-type">void</span> <span class="enscript-function-name">HASH_UPDATE</span> (HASH_CTX *c, <span class="enscript-type">const</span> <span class="enscript-type">void</span> *data_, <span class="enscript-type">unsigned</span> <span class="enscript-type">long</span> len)
    436. 

  436. 	{
    437. 

  437. 	<span class="enscript-type">const</span> <span class="enscript-type">unsigned</span> <span class="enscript-type">char</span> *data=data_;
    438. 

  438. 	<span class="enscript-type">register</span> HASH_LONG * p;
    439. 

  439. 	<span class="enscript-type">register</span> <span class="enscript-type">unsigned</span> <span class="enscript-type">long</span> l;
    440. 

  440. 	<span class="enscript-type">int</span> sw,sc,ew,ec;
    441. 

  441. 

  442. 	<span class="enscript-keyword">if</span> (len==0) <span class="enscript-keyword">return</span>;
    443. 

  443. 

  444. 	l=(c-&gt;Nl+(len&lt;&lt;3))&amp;0xffffffffL;
    445. 

  445. 	<span class="enscript-comment">/* 95-05-24 eay Fixed a bug with the overflow handling, thanks to
    446. 

  446. 	 * Wei Dai &lt;<a href="mailto:weidai@eskimo.com">weidai@eskimo.com</a>&gt; for pointing it out. */</span>
    447. 

  447. 	<span class="enscript-keyword">if</span> (l &lt; c-&gt;Nl) <span class="enscript-comment">/* overflow */</span>
    448. 

  448. 		c-&gt;Nh++;
    449. 

  449. 	c-&gt;Nh+=(len&gt;&gt;29);
    450. 

  450. 	c-&gt;Nl=l;
    451. 

  451. 

  452. 	<span class="enscript-keyword">if</span> (c-&gt;num != 0)
    453. 

  453. 		{
    454. 

  454. 		p=c-&gt;data;
    455. 

  455. 		sw=c-&gt;num&gt;&gt;2;
    456. 

  456. 		sc=c-&gt;num&amp;0x03;
    457. 

  457. 

  458. 		<span class="enscript-keyword">if</span> ((c-&gt;num+len) &gt;= HASH_CBLOCK)
    459. 

  459. 			{
    460. 

  460. 			l=p[sw]; HOST_p_c2l(data,l,sc); p[sw++]=l;
    461. 

  461. 			<span class="enscript-keyword">for</span> (; sw&lt;HASH_LBLOCK; sw++)
    462. 

  462. 				{
    463. 

  463. 				HOST_c2l(data,l); p[sw]=l;
    464. 

  464. 				}
    465. 

  465. 			HASH_BLOCK_HOST_ORDER (c,p,1);
    466. 

  466. 			len-=(HASH_CBLOCK-c-&gt;num);
    467. 

  467. 			c-&gt;num=0;
    468. 

  468. 			<span class="enscript-comment">/* drop through and do the rest */</span>
    469. 

  469. 			}
    470. 

  470. 		<span class="enscript-keyword">else</span>
    471. 

  471. 			{
    472. 

  472. 			c-&gt;num+=len;
    473. 

  473. 			<span class="enscript-keyword">if</span> ((sc+len) &lt; 4) <span class="enscript-comment">/* ugly, add char's to a word */</span>
    474. 

  474. 				{
    475. 

  475. 				l=p[sw]; HOST_p_c2l_p(data,l,sc,len); p[sw]=l;
    476. 

  476. 				}
    477. 

  477. 			<span class="enscript-keyword">else</span>
    478. 

  478. 				{
    479. 

  479. 				ew=(c-&gt;num&gt;&gt;2);
    480. 

  480. 				ec=(c-&gt;num&amp;0x03);
    481. 

  481. 				l=p[sw]; HOST_p_c2l(data,l,sc); p[sw++]=l;
    482. 

  482. 				<span class="enscript-keyword">for</span> (; sw &lt; ew; sw++)
    483. 

  483. 					{
    484. 

  484. 					HOST_c2l(data,l); p[sw]=l;
    485. 

  485. 					}
    486. 

  486. 				<span class="enscript-keyword">if</span> (ec)
    487. 

  487. 					{
    488. 

  488. 					HOST_c2l_p(data,l,ec); p[sw]=l;
    489. 

  489. 					}
    490. 

  490. 				}
    491. 

  491. 			<span class="enscript-keyword">return</span>;
    492. 

  492. 			}
    493. 

  493. 		}
    494. 

  494. 

  495. 	sw=len/HASH_CBLOCK;
    496. 

  496. 	<span class="enscript-keyword">if</span> (sw &gt; 0)
    497. 

  497. 		{
    498. 

  498. #<span class="enscript-reference">if</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">HASH_BLOCK_DATA_ORDER_ALIGNED</span>)
    499. 

  499. 		<span class="enscript-comment">/*
    500. 

  500. 		 * Note that HASH_BLOCK_DATA_ORDER_ALIGNED gets defined
    501. 

  501. 		 * only if sizeof(HASH_LONG)==4.
    502. 

  502. 		 */</span>
    503. 

  503. 		<span class="enscript-keyword">if</span> ((((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)data)%4) == 0)
    504. 

  504. 			{
    505. 

  505. 			<span class="enscript-comment">/* data is properly aligned so that we can cast it: */</span>
    506. 

  506. 			HASH_BLOCK_DATA_ORDER_ALIGNED (c,(HASH_LONG *)data,sw);
    507. 

  507. 			sw*=HASH_CBLOCK;
    508. 

  508. 			data+=sw;
    509. 

  509. 			len-=sw;
    510. 

  510. 			}
    511. 

  511. 		<span class="enscript-keyword">else</span>
    512. 

  512. #<span class="enscript-reference">if</span> !<span class="enscript-reference">defined</span>(<span class="enscript-variable-name">HASH_BLOCK_DATA_ORDER</span>)
    513. 

  513. 			<span class="enscript-keyword">while</span> (sw--)
    514. 

  514. 				{
    515. 

  515. 				memcpy (p=c-&gt;data,data,HASH_CBLOCK);
    516. 

  516. 				HASH_BLOCK_DATA_ORDER_ALIGNED(c,p,1);
    517. 

  517. 				data+=HASH_CBLOCK;
    518. 

  518. 				len-=HASH_CBLOCK;
    519. 

  519. 				}
    520. 

  520. #<span class="enscript-reference">endif</span>
    521. 

  521. #<span class="enscript-reference">endif</span>
    522. 

  522. #<span class="enscript-reference">if</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">HASH_BLOCK_DATA_ORDER</span>)
    523. 

  523. 			{
    524. 

  524. 			HASH_BLOCK_DATA_ORDER(c,data,sw);
    525. 

  525. 			sw*=HASH_CBLOCK;
    526. 

  526. 			data+=sw;
    527. 

  527. 			len-=sw;
    528. 

  528. 			}
    529. 

  529. #<span class="enscript-reference">endif</span>
    530. 

  530. 		}
    531. 

  531. 

  532. 	<span class="enscript-keyword">if</span> (len!=0)
    533. 

  533. 		{
    534. 

  534. 		p = c-&gt;data;
    535. 

  535. 		c-&gt;num = len;
    536. 

  536. 		ew=len&gt;&gt;2;	<span class="enscript-comment">/* words to copy */</span>
    537. 

  537. 		ec=len&amp;0x03;
    538. 

  538. 		<span class="enscript-keyword">for</span> (; ew; ew--,p++)
    539. 

  539. 			{
    540. 

  540. 			HOST_c2l(data,l); *p=l;
    541. 

  541. 			}
    542. 

  542. 		HOST_c2l_p(data,l,ec);
    543. 

  543. 		*p=l;
    544. 

  544. 		}
    545. 

  545. 	}
    546. 

  546. 

  547. 

  548. <span class="enscript-type">void</span> <span class="enscript-function-name">HASH_TRANSFORM</span> (HASH_CTX *c, <span class="enscript-type">const</span> <span class="enscript-type">unsigned</span> <span class="enscript-type">char</span> *data)
    549. 

  549. 	{
    550. 

  550. #<span class="enscript-reference">if</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">HASH_BLOCK_DATA_ORDER_ALIGNED</span>)
    551. 

  551. 	<span class="enscript-keyword">if</span> ((((<span class="enscript-type">unsigned</span> <span class="enscript-type">long</span>)data)%4) == 0)
    552. 

  552. 		<span class="enscript-comment">/* data is properly aligned so that we can cast it: */</span>
    553. 

  553. 		HASH_BLOCK_DATA_ORDER_ALIGNED (c,(HASH_LONG *)data,1);
    554. 

  554. 	<span class="enscript-keyword">else</span>
    555. 

  555. #<span class="enscript-reference">if</span> !<span class="enscript-reference">defined</span>(<span class="enscript-variable-name">HASH_BLOCK_DATA_ORDER</span>)
    556. 

  556. 		{
    557. 

  557. 		memcpy (c-&gt;data,data,HASH_CBLOCK);
    558. 

  558. 		HASH_BLOCK_DATA_ORDER_ALIGNED (c,c-&gt;data,1);
    559. 

  559. 		}
    560. 

  560. #<span class="enscript-reference">endif</span>
    561. 

  561. #<span class="enscript-reference">endif</span>
    562. 

  562. #<span class="enscript-reference">if</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">HASH_BLOCK_DATA_ORDER</span>)
    563. 

  563. 	HASH_BLOCK_DATA_ORDER (c,data,1);
    564. 

  564. #<span class="enscript-reference">endif</span>
    565. 

  565. 	}
    566. 

  566. 

  567. 

  568. <span class="enscript-type">void</span> <span class="enscript-function-name">HASH_FINAL</span> (<span class="enscript-type">unsigned</span> <span class="enscript-type">char</span> *md, HASH_CTX *c)
    569. 

  569. 	{
    570. 

  570. 	<span class="enscript-type">register</span> HASH_LONG *p;
    571. 

  571. 	<span class="enscript-type">register</span> <span class="enscript-type">unsigned</span> <span class="enscript-type">long</span> l;
    572. 

  572. 	<span class="enscript-type">register</span> <span class="enscript-type">int</span> i,j;
    573. 

  573. 	<span class="enscript-type">static</span> <span class="enscript-type">const</span> <span class="enscript-type">unsigned</span> <span class="enscript-type">char</span> end[4]={0x80,0x00,0x00,0x00};
    574. 

  574. 	<span class="enscript-type">const</span> <span class="enscript-type">unsigned</span> <span class="enscript-type">char</span> *cp=end;
    575. 

  575. 

  576. 	<span class="enscript-comment">/* c-&gt;num should definitly have room for at least one more byte. */</span>
    577. 

  577. 	p=c-&gt;data;
    578. 

  578. 	i=c-&gt;num&gt;&gt;2;
    579. 

  579. 	j=c-&gt;num&amp;0x03;
    580. 

  580. 

  581. #<span class="enscript-reference">if</span> 0
    582. 

  582. 	<span class="enscript-comment">/* purify often complains about the following line as an
    583. 

  583. 	 * Uninitialized Memory Read.  While this can be true, the
    584. 

  584. 	 * following p_c2l macro will reset l when that case is true.
    585. 

  585. 	 * This is because j&amp;0x03 contains the number of 'valid' bytes
    586. 

  586. 	 * already in p[i].  If and only if j&amp;0x03 == 0, the UMR will
    587. 

  587. 	 * occur but this is also the only time p_c2l will do
    588. 

  588. 	 * l= *(cp++) instead of l|= *(cp++)
    589. 

  589. 	 * Many thanks to Alex Tang &lt;<a href="mailto:altitude@cic.net">altitude@cic.net</a>&gt; for pickup this
    590. 

  590. 	 * 'potential bug' */</span>
    591. 

  591. #<span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">PURIFY</span>
    592. 

  592. 	<span class="enscript-keyword">if</span> (j==0) p[i]=0; <span class="enscript-comment">/* Yeah, but that's not the way to fix it:-) */</span>
    593. 

  593. #<span class="enscript-reference">endif</span>
    594. 

  594. 	l=p[i];
    595. 

  595. #<span class="enscript-reference">else</span>
    596. 

  596. 	l = (j==0) ? 0 : p[i];
    597. 

  597. #<span class="enscript-reference">endif</span>
    598. 

  598. 	HOST_p_c2l(cp,l,j); p[i++]=l; <span class="enscript-comment">/* i is the next 'undefined word' */</span>
    599. 

  599. 

  600. 	<span class="enscript-keyword">if</span> (i&gt;(HASH_LBLOCK-2)) <span class="enscript-comment">/* save room for Nl and Nh */</span>
    601. 

  601. 		{
    602. 

  602. 		<span class="enscript-keyword">if</span> (i&lt;HASH_LBLOCK) p[i]=0;
    603. 

  603. 		HASH_BLOCK_HOST_ORDER (c,p,1);
    604. 

  604. 		i=0;
    605. 

  605. 		}
    606. 

  606. 	<span class="enscript-keyword">for</span> (; i&lt;(HASH_LBLOCK-2); i++)
    607. 

  607. 		p[i]=0;
    608. 

  608. 

  609. #<span class="enscript-reference">if</span>   <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">DATA_ORDER_IS_BIG_ENDIAN</span>)
    610. 

  610. 	p[HASH_LBLOCK-2]=c-&gt;Nh;
    611. 

  611. 	p[HASH_LBLOCK-1]=c-&gt;Nl;
    612. 

  612. #<span class="enscript-reference">elif</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">DATA_ORDER_IS_LITTLE_ENDIAN</span>)
    613. 

  613. 	p[HASH_LBLOCK-2]=c-&gt;Nl;
    614. 

  614. 	p[HASH_LBLOCK-1]=c-&gt;Nh;
    615. 

  615. #<span class="enscript-reference">endif</span>
    616. 

  616. 	HASH_BLOCK_HOST_ORDER (c,p,1);
    617. 

  617. 

  618. #<span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">HASH_MAKE_STRING</span>
    619. 

  619. #<span class="enscript-reference">error</span> <span class="enscript-string">&quot;HASH_MAKE_STRING must be defined!&quot;</span>
    620. 

  620. #<span class="enscript-reference">else</span>
    621. 

  621. 	HASH_MAKE_STRING(c,md);
    622. 

  622. #<span class="enscript-reference">endif</span>
    623. 

  623. 

  624. 	c-&gt;num=0;
    625. 

  625. 	<span class="enscript-comment">/* clear stuff, HASH_BLOCK may be leaving some stuff on the stack
    626. 

  626. 	 * but I'm not worried :-)
    627. 

  627. 	OPENSSL_cleanse((void *)c,sizeof(HASH_CTX));
    628. 

  628. 	 */</span>
    629. 

  629. 	}
    630. 

  630. </pre>
    631. 

  631. <hr />
    632. 

  632. </body></html>
    633.