WebSVN – Kolibri OS – Diff – /contrib/toolchain/binutils/include/md5.h


/* md5.h - Declaration of functions and data types used for MD5 sum
   computing library functions.
   Copyright (C) 1995-2015 Free Software Foundation, Inc.
   NOTE: The canonical source of this file is maintained with the GNU C
   Library.  Bugs can be reported to bug-glibc@prep.ai.mit.edu.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the
   Free Software Foundation; either version 2, or (at your option) any
   later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
   Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
 
#ifndef _MD5_H
#define _MD5_H 1
 
#include 
 
#if defined HAVE_LIMITS_H || _LIBC
# include 
#endif
 
#include "ansidecl.h"
 
/* The following contortions are an attempt to use the C preprocessor
   to determine an unsigned integral type that is 32 bits wide.  An
   alternative approach is to use autoconf's AC_CHECK_SIZEOF macro, but
   doing that would require that the configure script compile and *run*
   the resulting executable.  Locally running cross-compiled executables
   is usually not possible.  */
 
#ifdef _LIBC
# include 
typedef u_int32_t md5_uint32;
typedef uintptr_t md5_uintptr;
#elif defined (HAVE_SYS_TYPES_H) && defined (HAVE_STDINT_H)
#include 
#include 
typedef uint32_t md5_uint32;
typedef uintptr_t md5_uintptr;
#else
#  define INT_MAX_32_BITS 2147483647
 
/* If UINT_MAX isn't defined, assume it's a 32-bit type.
   This should be valid for all systems GNU cares about because
   that doesn't include 16-bit systems, and only modern systems
   (that certainly have ) have 64+-bit integral types.  */
 
# ifndef INT_MAX
#  define INT_MAX INT_MAX_32_BITS
# endif
 
# if INT_MAX == INT_MAX_32_BITS
   typedef unsigned int md5_uint32;
# else
#  if SHRT_MAX == INT_MAX_32_BITS
    typedef unsigned short md5_uint32;
#  else
#   if LONG_MAX == INT_MAX_32_BITS
     typedef unsigned long md5_uint32;
#   else
     /* The following line is intended to evoke an error.
        Using #error is not portable enough.  */
     "Cannot determine unsigned 32-bit data type."
#   endif
#  endif
# endif
/* We have to make a guess about the integer type equivalent in size
   to pointers which should always be correct.  */
typedef unsigned long int md5_uintptr;
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Structure to save state of computation between the single steps.  */
struct md5_ctx
{
  md5_uint32 A;
  md5_uint32 B;
  md5_uint32 C;
  md5_uint32 D;
 
  md5_uint32 total[2];
  md5_uint32 buflen;
  char buffer[128] ATTRIBUTE_ALIGNED_ALIGNOF(md5_uint32);
};
 
/*
 * The following three functions are build up the low level used in
 * the functions `md5_stream' and `md5_buffer'.
 */
 
/* Initialize structure containing state of computation.
   (RFC 1321, 3.3: Step 3)  */
extern void md5_init_ctx (struct md5_ctx *ctx);
 
/* Starting with the result of former calls of this function (or the
   initialization function update the context for the next LEN bytes
   starting at BUFFER.
   It is necessary that LEN is a multiple of 64!!! */
extern void md5_process_block (const void *buffer, size_t len,
                               struct md5_ctx *ctx);
 
/* Starting with the result of former calls of this function (or the
   initialization function update the context for the next LEN bytes
   starting at BUFFER.
   It is NOT required that LEN is a multiple of 64.  */
extern void md5_process_bytes (const void *buffer, size_t len,
                               struct md5_ctx *ctx);
 
/* Process the remaining bytes in the buffer and put result from CTX
   in first 16 bytes following RESBUF.  The result is always in little
   endian byte order, so that a byte-wise output yields to the wanted
   ASCII representation of the message digest.
 
   IMPORTANT: On some systems it is required that RESBUF is correctly
   aligned for a 32 bits value.  */
extern void *md5_finish_ctx (struct md5_ctx *ctx, void *resbuf);
 
 
/* Put result from CTX in first 16 bytes following RESBUF.  The result is
   always in little endian byte order, so that a byte-wise output yields
   to the wanted ASCII representation of the message digest.
 
   IMPORTANT: On some systems it is required that RESBUF is correctly
   aligned for a 32 bits value.  */
extern void *md5_read_ctx (const struct md5_ctx *ctx, void *resbuf);
 
 
/* Compute MD5 message digest for bytes read from STREAM.  The
   resulting message digest number will be written into the 16 bytes
   beginning at RESBLOCK.  */
extern int md5_stream (FILE *stream, void *resblock);
 
/* Compute MD5 message digest for LEN bytes beginning at BUFFER.  The
   result is always in little endian byte order, so that a byte-wise
   output yields to the wanted ASCII representation of the message
   digest.  */
extern void *md5_buffer (const char *buffer, size_t len, void *resblock);
 
#ifdef __cplusplus
}
#endif
 
#endif

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/include/md5.h – Rev 5191 → 6324

Rev 5191		Rev 6324
1	/* md5.h - Declaration of functions and data types used for MD5 sum	1	/* md5.h - Declaration of functions and data types used for MD5 sum
2	computing library functions.	2	computing library functions.
3	Copyright 1995, 1996, 2000 Free Software Foundation, Inc.	3	Copyright (C) 1995-2015 Free Software Foundation, Inc.
4	NOTE: The canonical source of this file is maintained with the GNU C	4	NOTE: The canonical source of this file is maintained with the GNU C
5	Library. Bugs can be reported to bug-glibc@prep.ai.mit.edu.	5	Library. Bugs can be reported to bug-glibc@prep.ai.mit.edu.
6		6
7	This program is free software; you can redistribute it and/or modify it	7	This program is free software; you can redistribute it and/or modify it
8	under the terms of the GNU General Public License as published by the	8	under the terms of the GNU General Public License as published by the
9	Free Software Foundation; either version 2, or (at your option) any	9	Free Software Foundation; either version 2, or (at your option) any
10	later version.	10	later version.
11		11
12	This program is distributed in the hope that it will be useful,	12	This program is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.	15	GNU General Public License for more details.
16		16
17	You should have received a copy of the GNU General Public License	17	You should have received a copy of the GNU General Public License
18	along with this program; if not, write to the Free Software Foundation,	18	along with this program; if not, write to the Free Software Foundation,
19	Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */	19	Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
20		20
21	#ifndef _MD5_H	21	#ifndef _MD5_H
22	#define _MD5_H 1	22	#define _MD5_H 1
23		23
24	#include	24	#include
25		25
26	#if defined HAVE_LIMITS_H \|\| _LIBC	26	#if defined HAVE_LIMITS_H \|\| _LIBC
27	# include	27	# include
28	#endif	28	#endif
29		29
30	#include "ansidecl.h"	30	#include "ansidecl.h"
31		31
32	/* The following contortions are an attempt to use the C preprocessor	32	/* The following contortions are an attempt to use the C preprocessor
33	to determine an unsigned integral type that is 32 bits wide. An	33	to determine an unsigned integral type that is 32 bits wide. An
34	alternative approach is to use autoconf's AC_CHECK_SIZEOF macro, but	34	alternative approach is to use autoconf's AC_CHECK_SIZEOF macro, but
35	doing that would require that the configure script compile and run	35	doing that would require that the configure script compile and run
36	the resulting executable. Locally running cross-compiled executables	36	the resulting executable. Locally running cross-compiled executables
37	is usually not possible. */	37	is usually not possible. */
38		38
39	#ifdef _LIBC	39	#ifdef _LIBC
40	# include	40	# include
41	typedef u_int32_t md5_uint32;	41	typedef u_int32_t md5_uint32;
42	typedef uintptr_t md5_uintptr;	42	typedef uintptr_t md5_uintptr;
43	#elif defined (HAVE_SYS_TYPES_H) && defined (HAVE_STDINT_H)	43	#elif defined (HAVE_SYS_TYPES_H) && defined (HAVE_STDINT_H)
44	#include	44	#include
45	#include	45	#include
46	typedef uint32_t md5_uint32;	46	typedef uint32_t md5_uint32;
47	typedef uintptr_t md5_uintptr;	47	typedef uintptr_t md5_uintptr;
48	#else	48	#else
49	# define INT_MAX_32_BITS 2147483647	49	# define INT_MAX_32_BITS 2147483647
50		50
51	/* If UINT_MAX isn't defined, assume it's a 32-bit type.	51	/* If UINT_MAX isn't defined, assume it's a 32-bit type.
52	This should be valid for all systems GNU cares about because	52	This should be valid for all systems GNU cares about because
53	that doesn't include 16-bit systems, and only modern systems	53	that doesn't include 16-bit systems, and only modern systems
54	(that certainly have ) have 64+-bit integral types. */	54	(that certainly have ) have 64+-bit integral types. */
55		55
56	# ifndef INT_MAX	56	# ifndef INT_MAX
57	# define INT_MAX INT_MAX_32_BITS	57	# define INT_MAX INT_MAX_32_BITS
58	# endif	58	# endif
59		59
60	# if INT_MAX == INT_MAX_32_BITS	60	# if INT_MAX == INT_MAX_32_BITS
61	typedef unsigned int md5_uint32;	61	typedef unsigned int md5_uint32;
62	# else	62	# else
63	# if SHRT_MAX == INT_MAX_32_BITS	63	# if SHRT_MAX == INT_MAX_32_BITS
64	typedef unsigned short md5_uint32;	64	typedef unsigned short md5_uint32;
65	# else	65	# else
66	# if LONG_MAX == INT_MAX_32_BITS	66	# if LONG_MAX == INT_MAX_32_BITS
67	typedef unsigned long md5_uint32;	67	typedef unsigned long md5_uint32;
68	# else	68	# else
69	/* The following line is intended to evoke an error.	69	/* The following line is intended to evoke an error.
70	Using #error is not portable enough. */	70	Using #error is not portable enough. */
71	"Cannot determine unsigned 32-bit data type."	71	"Cannot determine unsigned 32-bit data type."
72	# endif	72	# endif
73	# endif	73	# endif
74	# endif	74	# endif
75	/* We have to make a guess about the integer type equivalent in size	75	/* We have to make a guess about the integer type equivalent in size
76	to pointers which should always be correct. */	76	to pointers which should always be correct. */
77	typedef unsigned long int md5_uintptr;	77	typedef unsigned long int md5_uintptr;
78	#endif	78	#endif
79		79
80	#ifdef __cplusplus	80	#ifdef __cplusplus
81	extern "C" {	81	extern "C" {
82	#endif	82	#endif
83		83
84	/* Structure to save state of computation between the single steps. */	84	/* Structure to save state of computation between the single steps. */
85	struct md5_ctx	85	struct md5_ctx
86	{	86	{
87	md5_uint32 A;	87	md5_uint32 A;
88	md5_uint32 B;	88	md5_uint32 B;
89	md5_uint32 C;	89	md5_uint32 C;
90	md5_uint32 D;	90	md5_uint32 D;
91		91
92	md5_uint32 total[2];	92	md5_uint32 total[2];
93	md5_uint32 buflen;	93	md5_uint32 buflen;
94	char buffer[128] ATTRIBUTE_ALIGNED_ALIGNOF(md5_uint32);	94	char buffer[128] ATTRIBUTE_ALIGNED_ALIGNOF(md5_uint32);
95	};	95	};
96		96
97	/*	97	/*
98	* The following three functions are build up the low level used in	98	* The following three functions are build up the low level used in
99	* the functions `md5_stream' and `md5_buffer'.	99	* the functions `md5_stream' and `md5_buffer'.
100	*/	100	*/
101		101
102	/* Initialize structure containing state of computation.	102	/* Initialize structure containing state of computation.
103	(RFC 1321, 3.3: Step 3) */	103	(RFC 1321, 3.3: Step 3) */
104	extern void md5_init_ctx (struct md5_ctx *ctx);	104	extern void md5_init_ctx (struct md5_ctx *ctx);
105		105
106	/* Starting with the result of former calls of this function (or the	106	/* Starting with the result of former calls of this function (or the
107	initialization function update the context for the next LEN bytes	107	initialization function update the context for the next LEN bytes
108	starting at BUFFER.	108	starting at BUFFER.
109	It is necessary that LEN is a multiple of 64!!! */	109	It is necessary that LEN is a multiple of 64!!! */
110	extern void md5_process_block (const void *buffer, size_t len,	110	extern void md5_process_block (const void *buffer, size_t len,
111	struct md5_ctx *ctx);	111	struct md5_ctx *ctx);
112		112
113	/* Starting with the result of former calls of this function (or the	113	/* Starting with the result of former calls of this function (or the
114	initialization function update the context for the next LEN bytes	114	initialization function update the context for the next LEN bytes
115	starting at BUFFER.	115	starting at BUFFER.
116	It is NOT required that LEN is a multiple of 64. */	116	It is NOT required that LEN is a multiple of 64. */
117	extern void md5_process_bytes (const void *buffer, size_t len,	117	extern void md5_process_bytes (const void *buffer, size_t len,
118	struct md5_ctx *ctx);	118	struct md5_ctx *ctx);
119		119
120	/* Process the remaining bytes in the buffer and put result from CTX	120	/* Process the remaining bytes in the buffer and put result from CTX
121	in first 16 bytes following RESBUF. The result is always in little	121	in first 16 bytes following RESBUF. The result is always in little
122	endian byte order, so that a byte-wise output yields to the wanted	122	endian byte order, so that a byte-wise output yields to the wanted
123	ASCII representation of the message digest.	123	ASCII representation of the message digest.
124		124
125	IMPORTANT: On some systems it is required that RESBUF is correctly	125	IMPORTANT: On some systems it is required that RESBUF is correctly
126	aligned for a 32 bits value. */	126	aligned for a 32 bits value. */
127	extern void md5_finish_ctx (struct md5_ctx ctx, void *resbuf);	127	extern void md5_finish_ctx (struct md5_ctx ctx, void *resbuf);
128		128
129		129
130	/* Put result from CTX in first 16 bytes following RESBUF. The result is	130	/* Put result from CTX in first 16 bytes following RESBUF. The result is
131	always in little endian byte order, so that a byte-wise output yields	131	always in little endian byte order, so that a byte-wise output yields
132	to the wanted ASCII representation of the message digest.	132	to the wanted ASCII representation of the message digest.
133		133
134	IMPORTANT: On some systems it is required that RESBUF is correctly	134	IMPORTANT: On some systems it is required that RESBUF is correctly
135	aligned for a 32 bits value. */	135	aligned for a 32 bits value. */
136	extern void md5_read_ctx (const struct md5_ctx ctx, void *resbuf);	136	extern void md5_read_ctx (const struct md5_ctx ctx, void *resbuf);
137		137
138		138
139	/* Compute MD5 message digest for bytes read from STREAM. The	139	/* Compute MD5 message digest for bytes read from STREAM. The
140	resulting message digest number will be written into the 16 bytes	140	resulting message digest number will be written into the 16 bytes
141	beginning at RESBLOCK. */	141	beginning at RESBLOCK. */
142	extern int md5_stream (FILE stream, void resblock);	142	extern int md5_stream (FILE stream, void resblock);
143		143
144	/* Compute MD5 message digest for LEN bytes beginning at BUFFER. The	144	/* Compute MD5 message digest for LEN bytes beginning at BUFFER. The
145	result is always in little endian byte order, so that a byte-wise	145	result is always in little endian byte order, so that a byte-wise
146	output yields to the wanted ASCII representation of the message	146	output yields to the wanted ASCII representation of the message
147	digest. */	147	digest. */
148	extern void md5_buffer (const char buffer, size_t len, void *resblock);	148	extern void md5_buffer (const char buffer, size_t len, void *resblock);
149		149
150	#ifdef __cplusplus	150	#ifdef __cplusplus
151	}	151	}
152	#endif	152	#endif
153		153
154	#endif	154	#endif