ViewVC Help

View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing

root/src/vendor-crypto/openssl/dist/apps/openssl.c

Comparing vendor-crypto/openssl/dist/apps/openssl.c (file contents):
Revision 6975 by laffer1, Sun Oct 12 20:29:54 2014 UTC vs.
Revision 6976 by laffer1, Fri Mar 20 00:01:13 2015 UTC

#	Line 5 | Line 5
5		* This package is an SSL implementation written
6		* by Eric Young (eay@cryptsoft.com).
7		* The implementation was written so as to conform with Netscapes SSL.
8	<	*
8	>	*
9		* This library is free for commercial and non-commercial use as long as
10		* the following conditions are aheared to.  The following conditions
11		* apply to all code found in this distribution, be it the RC4, RSA,
12		* lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13		* included with this distribution is covered by the same copyright terms
14		* except that the holder is Tim Hudson (tjh@cryptsoft.com).
15	<	*
15	>	*
16		* Copyright remains Eric Young's, and as such any Copyright notices in
17		* the code are not to be removed.
18		* If this package is used in a product, Eric Young should be given attribution
19		* as the author of the parts of the library used.
20		* This can be in the form of a textual message at program startup or
21		* in documentation (online or textual) provided with the package.
22	<	*
22	>	*
23		* Redistribution and use in source and binary forms, with or without
24		* modification, are permitted provided that the following conditions
25		* are met:
#	Line 34 | Line 34
34		*     Eric Young (eay@cryptsoft.com)"
35		*    The word 'cryptographic' can be left out if the rouines from the library
36		*    being used are not cryptographic related :-).
37	<	* 4. If you include any Windows specific code (or a derivative thereof) from
37	>	* 4. If you include any Windows specific code (or a derivative thereof) from
38		*    the apps directory (application code) you must include an acknowledgement:
39		*    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40	<	*
40	>	*
41		* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
#	Line 49 | Line 49
49		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51		* SUCH DAMAGE.
52	<	*
52	>	*
53		* The licence and distribution terms for any publically available version or
54		* derivative of this code cannot be changed.  i.e. this code cannot simply be
55		* copied and put under another distribution licence
#	Line 63 | Line 63
63		* are met:
64		*
65		* 1. Redistributions of source code must retain the above copyright
66	<	*    notice, this list of conditions and the following disclaimer.
66	>	*    notice, this list of conditions and the following disclaimer.
67		*
68		* 2. Redistributions in binary form must reproduce the above copyright
69		*    notice, this list of conditions and the following disclaimer in
#	Line 109 | Line 109
109		*
110		*/
111
112	–
112		#include <stdio.h>
113		#include <string.h>
114		#include <stdlib.h>
115	<	#define OPENSSL_C /* tells apps.h to use complete apps_startup() */
115	>	#define OPENSSL_C               /* tells apps.h to use complete
116	>	* apps_startup() */
117		#include "apps.h"
118		#include <openssl/bio.h>
119		#include <openssl/crypto.h>
#	Line 123 | Line 123
123		#include <openssl/pem.h>
124		#include <openssl/ssl.h>
125		#ifndef OPENSSL_NO_ENGINE
126	<	#include <openssl/engine.h>
126	>	# include <openssl/engine.h>
127		#endif
128	<	#define USE_SOCKETS /* needed for the _O_BINARY defs in the MS world */
128	>	#define USE_SOCKETS             /* needed for the _O_BINARY defs in the MS
129	>	* world */
130		#include "progs.h"
131		#include "s_apps.h"
132		#include <openssl/err.h>
133
134	<	/* The LHASH callbacks ("hash" & "cmp") have been replaced by functions with the
135	<	* base prototypes (we cast each variable inside the function to the required
136	<	* type of "FUNCTION*"). This removes the necessity for macro-generated wrapper
137	<	* functions. */
134	>	/*
135	>	* The LHASH callbacks ("hash" & "cmp") have been replaced by functions with
136	>	* the base prototypes (we cast each variable inside the function to the
137	>	* required type of "FUNCTION*"). This removes the necessity for
138	>	* macro-generated wrapper functions.
139	>	*/
140
141		/* static unsigned long MS_CALLBACK hash(FUNCTION *a); */
142		static unsigned long MS_CALLBACK hash(const void *a_void);
143		/* static int MS_CALLBACK cmp(FUNCTION *a,FUNCTION *b); */
144	<	static int MS_CALLBACK cmp(const void *a_void,const void *b_void);
145	<	static LHASH *prog_init(void );
146	<	static int do_cmd(LHASH *prog,int argc,char *argv[]);
147	<	char *default_config_file=NULL;
144	>	static int MS_CALLBACK cmp(const void *a_void, const void *b_void);
145	>	static LHASH *prog_init(void);
146	>	static int do_cmd(LHASH *prog, int argc, char *argv[]);
147	>	char *default_config_file = NULL;
148
149		/* Make sure there is only one when MONOLITH is defined */
150		#ifdef MONOLITH
151	<	CONF *config=NULL;
152	<	BIO *bio_err=NULL;
153	<	int in_FIPS_mode=0;
151	>	CONF *config = NULL;
152	>	BIO *bio_err = NULL;
153	>	int in_FIPS_mode = 0;
154		#endif
155
153	–
156		static void lock_dbg_cb(int mode, int type, const char *file, int line)
157	<	{
158	<	static int modes[CRYPTO_NUM_LOCKS]; /* = {0, 0, ... } */
159	<	const char *errstr = NULL;
160	<	int rw;
159	<
160	<	rw = mode & (CRYPTO_READ|CRYPTO_WRITE);
161	<	if (!((rw == CRYPTO_READ) || (rw == CRYPTO_WRITE)))
162	<	{
163	<	errstr = "invalid mode";
164	<	goto err;
165	<	}
157	>	{
158	>	static int modes[CRYPTO_NUM_LOCKS]; /* = {0, 0, ... } */
159	>	const char *errstr = NULL;
160	>	int rw;
161
162	<	if (type < 0 || type >= CRYPTO_NUM_LOCKS)
163	<	{
164	<	errstr = "type out of bounds";
165	<	goto err;
166	<	}
162	>	rw = mode & (CRYPTO_READ | CRYPTO_WRITE);
163	>	if (!((rw == CRYPTO_READ) || (rw == CRYPTO_WRITE))) {
164	>	errstr = "invalid mode";
165	>	goto err;
166	>	}
167
168	<	if (mode & CRYPTO_LOCK)
169	<	{
170	<	if (modes[type])
171	<	{
177	<	errstr = "already locked";
178	<	/* must not happen in a single-threaded program
179	<	* (would deadlock) */
180	<	goto err;
181	<	}
168	>	if (type < 0 || type >= CRYPTO_NUM_LOCKS) {
169	>	errstr = "type out of bounds";
170	>	goto err;
171	>	}
172
173	<	modes[type] = rw;
174	<	}
175	<	else if (mode & CRYPTO_UNLOCK)
176	<	{
177	<	if (!modes[type])
178	<	{
179	<	errstr = "not locked";
180	<	goto err;
191	<	}
192	<
193	<	if (modes[type] != rw)
194	<	{
195	<	errstr = (rw == CRYPTO_READ) ?
196	<	"CRYPTO_r_unlock on write lock" :
197	<	"CRYPTO_w_unlock on read lock";
198	<	}
173	>	if (mode & CRYPTO_LOCK) {
174	>	if (modes[type]) {
175	>	errstr = "already locked";
176	>	/*
177	>	* must not happen in a single-threaded program (would deadlock)
178	>	*/
179	>	goto err;
180	>	}
181
182	<	modes[type] = 0;
183	<	}
184	<	else
185	<	{
186	<	errstr = "invalid mode";
187	<	goto err;
206	<	}
182	>	modes[type] = rw;
183	>	} else if (mode & CRYPTO_UNLOCK) {
184	>	if (!modes[type]) {
185	>	errstr = "not locked";
186	>	goto err;
187	>	}
188
189	<	err:
190	<	if (errstr)
191	<	{
192	<	/* we cannot use bio_err here */
193	<	fprintf(stderr, "openssl (lock_dbg_cb): %s (mode=%d, type=%d) at %s:%d\n",
213	<	errstr, mode, type, file, line);
214	<	}
215	<	}
189	>	if (modes[type] != rw) {
190	>	errstr = (rw == CRYPTO_READ) ?
191	>	"CRYPTO_r_unlock on write lock" :
192	>	"CRYPTO_w_unlock on read lock";
193	>	}
194
195	+	modes[type] = 0;
196	+	} else {
197	+	errstr = "invalid mode";
198	+	goto err;
199	+	}
200
201	+	err:
202	+	if (errstr) {
203	+	/* we cannot use bio_err here */
204	+	fprintf(stderr,
205	+	"openssl (lock_dbg_cb): %s (mode=%d, type=%d) at %s:%d\n",
206	+	errstr, mode, type, file, line);
207	+	}
208	+	}
209	+
210		int main(int Argc, char *Argv[])
211	<	{
212	<	ARGS arg;
213	<	#define PROG_NAME_SIZE  39
214	<	char pname[PROG_NAME_SIZE+1];
215	<	FUNCTION f,*fp;
216	<	MS_STATIC const char *prompt;
217	<	MS_STATIC char buf[1024];
218	<	char *to_free=NULL;
219	<	int n,i,ret=0;
220	<	int argc;
221	<	char **argv,*p;
222	<	LHASH *prog=NULL;
223	<	long errline;
232	<
233	<	arg.data=NULL;
234	<	arg.count=0;
211	>	{
212	>	ARGS arg;
213	>	#define PROG_NAME_SIZE  39
214	>	char pname[PROG_NAME_SIZE + 1];
215	>	FUNCTION f, *fp;
216	>	MS_STATIC const char *prompt;
217	>	MS_STATIC char buf[1024];
218	>	char *to_free = NULL;
219	>	int n, i, ret = 0;
220	>	int argc;
221	>	char **argv, *p;
222	>	LHASH *prog = NULL;
223	>	long errline;
224
225	<	in_FIPS_mode = 0;
225	>	arg.data = NULL;
226	>	arg.count = 0;
227
228	<	if(getenv("OPENSSL_FIPS")) {
228	>	in_FIPS_mode = 0;
229	>
230	>	if (getenv("OPENSSL_FIPS")) {
231		#ifdef OPENSSL_FIPS
232	<	if (!FIPS_mode_set(1)) {
233	<	ERR_load_crypto_strings();
234	<	ERR_print_errors(BIO_new_fp(stderr,BIO_NOCLOSE));
235	<	EXIT(1);
236	<	}
237	<	in_FIPS_mode = 1;
232	>	if (!FIPS_mode_set(1)) {
233	>	ERR_load_crypto_strings();
234	>	ERR_print_errors(BIO_new_fp(stderr, BIO_NOCLOSE));
235	>	EXIT(1);
236	>	}
237	>	in_FIPS_mode = 1;
238		#else
239	<	fprintf(stderr, "FIPS mode not supported.\n");
240	<	EXIT(1);
239	>	fprintf(stderr, "FIPS mode not supported.\n");
240	>	EXIT(1);
241		#endif
242	<	}
242	>	}
243
244	<	if (bio_err == NULL)
245	<	if ((bio_err=BIO_new(BIO_s_file())) != NULL)
246	<	BIO_set_fp(bio_err,stderr,BIO_NOCLOSE|BIO_FP_TEXT);
244	>	if (bio_err == NULL)
245	>	if ((bio_err = BIO_new(BIO_s_file())) != NULL)
246	>	BIO_set_fp(bio_err, stderr, BIO_NOCLOSE | BIO_FP_TEXT);
247
248	<	if (getenv("OPENSSL_DEBUG_MEMORY") != NULL) /* if not defined, use compiled-in library defaults */
249	<	{
250	<	if (!(0 == strcmp(getenv("OPENSSL_DEBUG_MEMORY"), "off")))
251	<	{
252	<	CRYPTO_malloc_debug_init();
253	<	CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);
254	<	}
255	<	else
256	<	{
257	<	/* OPENSSL_DEBUG_MEMORY=off */
258	<	CRYPTO_set_mem_debug_functions(0, 0, 0, 0, 0);
259	<	}
268	<	}
269	<	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
248	>	if (getenv("OPENSSL_DEBUG_MEMORY") != NULL) { /* if not defined, use
249	>	* compiled-in library
250	>	* defaults */
251	>	if (!(0 == strcmp(getenv("OPENSSL_DEBUG_MEMORY"), "off"))) {
252	>	CRYPTO_malloc_debug_init();
253	>	CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);
254	>	} else {
255	>	/* OPENSSL_DEBUG_MEMORY=off */
256	>	CRYPTO_set_mem_debug_functions(0, 0, 0, 0, 0);
257	>	}
258	>	}
259	>	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
260
261		#if 0
262	<	if (getenv("OPENSSL_DEBUG_LOCKING") != NULL)
262	>	if (getenv("OPENSSL_DEBUG_LOCKING") != NULL)
263		#endif
264	<	{
265	<	CRYPTO_set_locking_callback(lock_dbg_cb);
266	<	}
264	>	{
265	>	CRYPTO_set_locking_callback(lock_dbg_cb);
266	>	}
267
268	<	apps_startup();
268	>	apps_startup();
269
270	<	/* Lets load up our environment a little */
271	<	p=getenv("OPENSSL_CONF");
272	<	if (p == NULL)
273	<	p=getenv("SSLEAY_CONF");
274	<	if (p == NULL)
275	<	p=to_free=make_config_name();
270	>	/* Lets load up our environment a little */
271	>	p = getenv("OPENSSL_CONF");
272	>	if (p == NULL)
273	>	p = getenv("SSLEAY_CONF");
274	>	if (p == NULL)
275	>	p = to_free = make_config_name();
276
277	<	default_config_file=p;
277	>	default_config_file = p;
278
279	<	config=NCONF_new(NULL);
280	<	i=NCONF_load(config,p,&errline);
281	<	if (i == 0)
282	<	{
283	<	NCONF_free(config);
284	<	config = NULL;
285	<	ERR_clear_error();
296	<	}
279	>	config = NCONF_new(NULL);
280	>	i = NCONF_load(config, p, &errline);
281	>	if (i == 0) {
282	>	NCONF_free(config);
283	>	config = NULL;
284	>	ERR_clear_error();
285	>	}
286
287	<	prog=prog_init();
287	>	prog = prog_init();
288
289	<	/* first check the program name */
290	<	program_name(Argv[0],pname,sizeof pname);
289	>	/* first check the program name */
290	>	program_name(Argv[0], pname, sizeof pname);
291
292	<	f.name=pname;
293	<	fp=(FUNCTION *)lh_retrieve(prog,&f);
294	<	if (fp != NULL)
295	<	{
296	<	Argv[0]=pname;
297	<	ret=fp->func(Argc,Argv);
298	<	goto end;
310	<	}
292	>	f.name = pname;
293	>	fp = (FUNCTION *) lh_retrieve(prog, &f);
294	>	if (fp != NULL) {
295	>	Argv[0] = pname;
296	>	ret = fp->func(Argc, Argv);
297	>	goto end;
298	>	}
299
300	<	/* ok, now check that there are not arguments, if there are,
301	<	* run with them, shifting the ssleay off the front */
302	<	if (Argc != 1)
303	<	{
304	<	Argc--;
305	<	Argv++;
306	<	ret=do_cmd(prog,Argc,Argv);
307	<	if (ret < 0) ret=0;
308	<	goto end;
309	<	}
300	>	/*
301	>	* ok, now check that there are not arguments, if there are, run with
302	>	* them, shifting the ssleay off the front
303	>	*/
304	>	if (Argc != 1) {
305	>	Argc--;
306	>	Argv++;
307	>	ret = do_cmd(prog, Argc, Argv);
308	>	if (ret < 0)
309	>	ret = 0;
310	>	goto end;
311	>	}
312
313	<	/* ok, lets enter the old 'OpenSSL>' mode */
324	<
325	<	for (;;)
326	<	{
327	<	ret=0;
328	<	p=buf;
329	<	n=sizeof buf;
330	<	i=0;
331	<	for (;;)
332	<	{
333	<	p[0]='\0';
334	<	if (i++)
335	<	prompt=">";
336	<	else    prompt="OpenSSL> ";
337	<	fputs(prompt,stdout);
338	<	fflush(stdout);
339	<	if (!fgets(p,n,stdin))
340	<	goto end;
341	<	if (p[0] == '\0') goto end;
342	<	i=strlen(p);
343	<	if (i <= 1) break;
344	<	if (p[i-2] != '\\') break;
345	<	i-=2;
346	<	p+=i;
347	<	n-=i;
348	<	}
349	<	if (!chopup_args(&arg,buf,&argc,&argv)) break;
313	>	/* ok, lets enter the old 'OpenSSL>' mode */
314
315	<	ret=do_cmd(prog,argc,argv);
316	<	if (ret < 0)
317	<	{
318	<	ret=0;
319	<	goto end;
320	<	}
321	<	if (ret != 0)
322	<	BIO_printf(bio_err,"error in %s\n",argv[0]);
323	<	(void)BIO_flush(bio_err);
324	<	}
325	<	BIO_printf(bio_err,"bad exit\n");
326	<	ret=1;
327	<	end:
328	<	if (to_free)
329	<	OPENSSL_free(to_free);
330	<	if (config != NULL)
331	<	{
332	<	NCONF_free(config);
333	<	config=NULL;
334	<	}
335	<	if (prog != NULL) lh_free(prog);
336	<	if (arg.data != NULL) OPENSSL_free(arg.data);
315	>	for (;;) {
316	>	ret = 0;
317	>	p = buf;
318	>	n = sizeof buf;
319	>	i = 0;
320	>	for (;;) {
321	>	p[0] = '\0';
322	>	if (i++)
323	>	prompt = ">";
324	>	else
325	>	prompt = "OpenSSL> ";
326	>	fputs(prompt, stdout);
327	>	fflush(stdout);
328	>	if (!fgets(p, n, stdin))
329	>	goto end;
330	>	if (p[0] == '\0')
331	>	goto end;
332	>	i = strlen(p);
333	>	if (i <= 1)
334	>	break;
335	>	if (p[i - 2] != '\\')
336	>	break;
337	>	i -= 2;
338	>	p += i;
339	>	n -= i;
340	>	}
341	>	if (!chopup_args(&arg, buf, &argc, &argv))
342	>	break;
343
344	<	apps_shutdown();
344	>	ret = do_cmd(prog, argc, argv);
345	>	if (ret < 0) {
346	>	ret = 0;
347	>	goto end;
348	>	}
349	>	if (ret != 0)
350	>	BIO_printf(bio_err, "error in %s\n", argv[0]);
351	>	(void)BIO_flush(bio_err);
352	>	}
353	>	BIO_printf(bio_err, "bad exit\n");
354	>	ret = 1;
355	>	end:
356	>	if (to_free)
357	>	OPENSSL_free(to_free);
358	>	if (config != NULL) {
359	>	NCONF_free(config);
360	>	config = NULL;
361	>	}
362	>	if (prog != NULL)
363	>	lh_free(prog);
364	>	if (arg.data != NULL)
365	>	OPENSSL_free(arg.data);
366
367	<	CRYPTO_mem_leaks(bio_err);
377	<	if (bio_err != NULL)
378	<	{
379	<	BIO_free(bio_err);
380	<	bio_err=NULL;
381	<	}
382	<	OPENSSL_EXIT(ret);
383	<	}
367	>	apps_shutdown();
368
369	+	CRYPTO_mem_leaks(bio_err);
370	+	if (bio_err != NULL) {
371	+	BIO_free(bio_err);
372	+	bio_err = NULL;
373	+	}
374	+	OPENSSL_EXIT(ret);
375	+	}
376	+
377		#define LIST_STANDARD_COMMANDS "list-standard-commands"
378		#define LIST_MESSAGE_DIGEST_COMMANDS "list-message-digest-commands"
379		#define LIST_CIPHER_COMMANDS "list-cipher-commands"
380
381		static int do_cmd(LHASH *prog, int argc, char *argv[])
382	<	{
383	<	FUNCTION f,*fp;
384	<	int i,ret=1,tp,nl;
382	>	{
383	>	FUNCTION f, *fp;
384	>	int i, ret = 1, tp, nl;
385
386	<	if ((argc <= 0) || (argv[0] == NULL))
387	<	{ ret=0; goto end; }
388	<	f.name=argv[0];
389	<	fp=(FUNCTION *)lh_retrieve(prog,&f);
390	<	if (fp != NULL)
391	<	{
392	<	ret=fp->func(argc,argv);
393	<	}
394	<	else if ((strncmp(argv[0],"no-",3)) == 0)
395	<	{
404	<	BIO *bio_stdout = BIO_new_fp(stdout,BIO_NOCLOSE);
386	>	if ((argc <= 0) || (argv[0] == NULL)) {
387	>	ret = 0;
388	>	goto end;
389	>	}
390	>	f.name = argv[0];
391	>	fp = (FUNCTION *) lh_retrieve(prog, &f);
392	>	if (fp != NULL) {
393	>	ret = fp->func(argc, argv);
394	>	} else if ((strncmp(argv[0], "no-", 3)) == 0) {
395	>	BIO *bio_stdout = BIO_new_fp(stdout, BIO_NOCLOSE);
396		#ifdef OPENSSL_SYS_VMS
397	<	{
398	<	BIO *tmpbio = BIO_new(BIO_f_linebuffer());
399	<	bio_stdout = BIO_push(tmpbio, bio_stdout);
400	<	}
397	>	{
398	>	BIO *tmpbio = BIO_new(BIO_f_linebuffer());
399	>	bio_stdout = BIO_push(tmpbio, bio_stdout);
400	>	}
401		#endif
402	<	f.name=argv[0]+3;
403	<	ret = (lh_retrieve(prog,&f) != NULL);
404	<	if (!ret)
405	<	BIO_printf(bio_stdout, "%s\n", argv[0]);
406	<	else
407	<	BIO_printf(bio_stdout, "%s\n", argv[0]+3);
408	<	BIO_free_all(bio_stdout);
409	<	goto end;
410	<	}
411	<	else if ((strcmp(argv[0],"quit") == 0) ||
412	<	(strcmp(argv[0],"q") == 0) ||
413	<	(strcmp(argv[0],"exit") == 0) ||
414	<	(strcmp(argv[0],"bye") == 0))
415	<	{
416	<	ret= -1;
417	<	goto end;
418	<	}
419	<	else if ((strcmp(argv[0],LIST_STANDARD_COMMANDS) == 0) ||
420	<	(strcmp(argv[0],LIST_MESSAGE_DIGEST_COMMANDS) == 0) ||
430	<	(strcmp(argv[0],LIST_CIPHER_COMMANDS) == 0))
431	<	{
432	<	int list_type;
433	<	BIO *bio_stdout;
402	>	f.name = argv[0] + 3;
403	>	ret = (lh_retrieve(prog, &f) != NULL);
404	>	if (!ret)
405	>	BIO_printf(bio_stdout, "%s\n", argv[0]);
406	>	else
407	>	BIO_printf(bio_stdout, "%s\n", argv[0] + 3);
408	>	BIO_free_all(bio_stdout);
409	>	goto end;
410	>	} else if ((strcmp(argv[0], "quit") == 0) ||
411	>	(strcmp(argv[0], "q") == 0) ||
412	>	(strcmp(argv[0], "exit") == 0) ||
413	>	(strcmp(argv[0], "bye") == 0)) {
414	>	ret = -1;
415	>	goto end;
416	>	} else if ((strcmp(argv[0], LIST_STANDARD_COMMANDS) == 0) ||
417	>	(strcmp(argv[0], LIST_MESSAGE_DIGEST_COMMANDS) == 0) ||
418	>	(strcmp(argv[0], LIST_CIPHER_COMMANDS) == 0)) {
419	>	int list_type;
420	>	BIO *bio_stdout;
421
422	<	if (strcmp(argv[0],LIST_STANDARD_COMMANDS) == 0)
423	<	list_type = FUNC_TYPE_GENERAL;
424	<	else if (strcmp(argv[0],LIST_MESSAGE_DIGEST_COMMANDS) == 0)
425	<	list_type = FUNC_TYPE_MD;
426	<	else /* strcmp(argv[0],LIST_CIPHER_COMMANDS) == 0 */
427	<	list_type = FUNC_TYPE_CIPHER;
428	<	bio_stdout = BIO_new_fp(stdout,BIO_NOCLOSE);
422	>	if (strcmp(argv[0], LIST_STANDARD_COMMANDS) == 0)
423	>	list_type = FUNC_TYPE_GENERAL;
424	>	else if (strcmp(argv[0], LIST_MESSAGE_DIGEST_COMMANDS) == 0)
425	>	list_type = FUNC_TYPE_MD;
426	>	else                    /* strcmp(argv[0],LIST_CIPHER_COMMANDS) == 0 */
427	>	list_type = FUNC_TYPE_CIPHER;
428	>	bio_stdout = BIO_new_fp(stdout, BIO_NOCLOSE);
429		#ifdef OPENSSL_SYS_VMS
430	<	{
431	<	BIO *tmpbio = BIO_new(BIO_f_linebuffer());
432	<	bio_stdout = BIO_push(tmpbio, bio_stdout);
433	<	}
430	>	{
431	>	BIO *tmpbio = BIO_new(BIO_f_linebuffer());
432	>	bio_stdout = BIO_push(tmpbio, bio_stdout);
433	>	}
434		#endif
435	<
436	<	for (fp=functions; fp->name != NULL; fp++)
437	<	if (fp->type == list_type)
438	<	BIO_printf(bio_stdout, "%s\n", fp->name);
439	<	BIO_free_all(bio_stdout);
440	<	ret=0;
441	<	goto end;
442	<	}
443	<	else
444	<	{
445	<	BIO_printf(bio_err,"openssl:Error: '%s' is an invalid command.\n",
446	<	argv[0]);
447	<	BIO_printf(bio_err, "\nStandard commands");
448	<	i=0;
449	<	tp=0;
463	<	for (fp=functions; fp->name != NULL; fp++)
464	<	{
465	<	nl=0;
435	>
436	>	for (fp = functions; fp->name != NULL; fp++)
437	>	if (fp->type == list_type)
438	>	BIO_printf(bio_stdout, "%s\n", fp->name);
439	>	BIO_free_all(bio_stdout);
440	>	ret = 0;
441	>	goto end;
442	>	} else {
443	>	BIO_printf(bio_err, "openssl:Error: '%s' is an invalid command.\n",
444	>	argv[0]);
445	>	BIO_printf(bio_err, "\nStandard commands");
446	>	i = 0;
447	>	tp = 0;
448	>	for (fp = functions; fp->name != NULL; fp++) {
449	>	nl = 0;
450		#ifdef OPENSSL_NO_CAMELLIA
451	<	if (((i++) % 5) == 0)
451	>	if (((i++) % 5) == 0)
452		#else
453	<	if (((i++) % 4) == 0)
453	>	if (((i++) % 4) == 0)
454		#endif
455	<	{
456	<	BIO_printf(bio_err,"\n");
457	<	nl=1;
458	<	}
459	<	if (fp->type != tp)
460	<	{
461	<	tp=fp->type;
462	<	if (!nl) BIO_printf(bio_err,"\n");
463	<	if (tp == FUNC_TYPE_MD)
464	<	{
465	<	i=1;
466	<	BIO_printf(bio_err,
467	<	"\nMessage Digest commands (see the `dgst' command for more details)\n");
468	<	}
469	<	else if (tp == FUNC_TYPE_CIPHER)
470	<	{
471	<	i=1;
472	<	BIO_printf(bio_err,"\nCipher commands (see the `enc' command for more details)\n");
489	<	}
490	<	}
455	>	{
456	>	BIO_printf(bio_err, "\n");
457	>	nl = 1;
458	>	}
459	>	if (fp->type != tp) {
460	>	tp = fp->type;
461	>	if (!nl)
462	>	BIO_printf(bio_err, "\n");
463	>	if (tp == FUNC_TYPE_MD) {
464	>	i = 1;
465	>	BIO_printf(bio_err,
466	>	"\nMessage Digest commands (see the `dgst' command for more details)\n");
467	>	} else if (tp == FUNC_TYPE_CIPHER) {
468	>	i = 1;
469	>	BIO_printf(bio_err,
470	>	"\nCipher commands (see the `enc' command for more details)\n");
471	>	}
472	>	}
473		#ifdef OPENSSL_NO_CAMELLIA
474	<	BIO_printf(bio_err,"%-15s",fp->name);
474	>	BIO_printf(bio_err, "%-15s", fp->name);
475		#else
476	<	BIO_printf(bio_err,"%-18s",fp->name);
476	>	BIO_printf(bio_err, "%-18s", fp->name);
477		#endif
478	<	}
479	<	BIO_printf(bio_err,"\n\n");
480	<	ret=0;
481	<	}
482	<	end:
483	<	return(ret);
484	<	}
478	>	}
479	>	BIO_printf(bio_err, "\n\n");
480	>	ret = 0;
481	>	}
482	>	end:
483	>	return (ret);
484	>	}
485
486	<	static int SortFnByName(const void *_f1,const void *_f2)
487	<	{
488	<	const FUNCTION *f1=_f1;
489	<	const FUNCTION *f2=_f2;
486	>	static int SortFnByName(const void *_f1, const void *_f2)
487	>	{
488	>	const FUNCTION *f1 = _f1;
489	>	const FUNCTION *f2 = _f2;
490
491	<	if(f1->type != f2->type)
492	<	return f1->type-f2->type;
493	<	return strcmp(f1->name,f2->name);
494	<	}
491	>	if (f1->type != f2->type)
492	>	return f1->type - f2->type;
493	>	return strcmp(f1->name, f2->name);
494	>	}
495
496		static LHASH *prog_init(void)
497	<	{
498	<	LHASH *ret;
499	<	FUNCTION *f;
500	<	size_t i;
497	>	{
498	>	LHASH *ret;
499	>	FUNCTION *f;
500	>	size_t i;
501
502	<	/* Purely so it looks nice when the user hits ? */
503	<	for(i=0,f=functions ; f->name != NULL ; ++f,++i)
504	<	;
523	<	qsort(functions,i,sizeof *functions,SortFnByName);
502	>	/* Purely so it looks nice when the user hits ? */
503	>	for (i = 0, f = functions; f->name != NULL; ++f, ++i) ;
504	>	qsort(functions, i, sizeof *functions, SortFnByName);
505
506	<	if ((ret=lh_new(hash, cmp)) == NULL)
507	<	return(NULL);
506	>	if ((ret = lh_new(hash, cmp)) == NULL)
507	>	return (NULL);
508
509	<	for (f=functions; f->name != NULL; f++)
510	<	lh_insert(ret,f);
511	<	return(ret);
512	<	}
509	>	for (f = functions; f->name != NULL; f++)
510	>	lh_insert(ret, f);
511	>	return (ret);
512	>	}
513
514		/* static int MS_CALLBACK cmp(FUNCTION *a, FUNCTION *b) */
515		static int MS_CALLBACK cmp(const void *a_void, const void *b_void)
516	<	{
517	<	return(strncmp(((const FUNCTION *)a_void)->name,
518	<	((const FUNCTION *)b_void)->name,8));
519	<	}
516	>	{
517	>	return (strncmp(((const FUNCTION *)a_void)->name,
518	>	((const FUNCTION *)b_void)->name, 8));
519	>	}
520
521		/* static unsigned long MS_CALLBACK hash(FUNCTION *a) */
522		static unsigned long MS_CALLBACK hash(const void *a_void)
523	<	{
524	<	return(lh_strhash(((const FUNCTION *)a_void)->name));
525	<	}
523	>	{
524	>	return (lh_strhash(((const FUNCTION *)a_void)->name));
525	>	}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines