[thirdparty/openssl.git] / apps / include / apps.h

/*
 * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#ifndef OSSL_APPS_H
# define OSSL_APPS_H

# include "e_os.h" /* struct timeval for DTLS */
# include "internal/nelem.h"
# include "internal/sockets.h" /* for openssl_fdset() */
# include <assert.h>

# include <stdarg.h>
# include <sys/types.h>
# ifndef OPENSSL_NO_POSIX_IO
#  include <sys/stat.h>
#  include <fcntl.h>
# endif

# include <openssl/e_os2.h>
# include <openssl/types.h>
# include <openssl/bio.h>
# include <openssl/x509.h>
# include <openssl/conf.h>
# include <openssl/txt_db.h>
# include <openssl/engine.h>
# include <openssl/ocsp.h>
# include <openssl/http.h>
# include <signal.h>
# include "apps_ui.h"
# include "opt.h"
# include "fmt.h"
# include "platform.h"

/*
 * quick macro when you need to pass an unsigned char instead of a char.
 * this is true for some implementations of the is*() functions, for
 * example.
 */
# define _UC(c) ((unsigned char)(c))

void app_RAND_load_conf(CONF *c, const char *section);
void app_RAND_write(void);

extern char *default_config_file;
extern BIO *bio_in;
extern BIO *bio_out;
extern BIO *bio_err;
extern const unsigned char tls13_aes128gcmsha256_id[];
extern const unsigned char tls13_aes256gcmsha384_id[];
extern BIO_ADDR *ourpeer;

BIO *dup_bio_in(int format);
BIO *dup_bio_out(int format);
BIO *dup_bio_err(int format);
BIO *bio_open_owner(const char *filename, int format, int private);
BIO *bio_open_default(const char *filename, char mode, int format);
BIO *bio_open_default_quiet(const char *filename, char mode, int format);
CONF *app_load_config_bio(BIO *in, const char *filename);
CONF *app_load_config(const char *filename);
CONF *app_load_config_quiet(const char *filename);
int app_load_modules(const CONF *config);
CONF *app_load_config_modules(const char *configfile);
void unbuffer(FILE *fp);
void wait_for_async(SSL *s);
# if defined(OPENSSL_SYS_MSDOS)
int has_stdin_waiting(void);
# endif

void corrupt_signature(const ASN1_STRING *signature);
int set_cert_times(X509 *x, const char *startdate, const char *enddate,
                   int days);

typedef struct args_st {
    int size;
    int argc;
    char **argv;
} ARGS;

/* We need both wrap and the "real" function because libcrypto uses both. */
int wrap_password_callback(char *buf, int bufsiz, int verify, void *cb_data);

int chopup_args(ARGS *arg, char *buf);
int dump_cert_text(BIO *out, X509 *x);
void print_name(BIO *out, const char *title, const X509_NAME *nm,
                unsigned long lflags);
void print_bignum_var(BIO *, const BIGNUM *, const char*,
                      int, unsigned char *);
void print_array(BIO *, const char *, int, const unsigned char *);
int set_nameopt(const char *arg);
unsigned long get_nameopt(void);
int set_cert_ex(unsigned long *flags, const char *arg);
int set_name_ex(unsigned long *flags, const char *arg);
int set_ext_copy(int *copy_type, const char *arg);
int copy_extensions(X509 *x, X509_REQ *req, int copy_type);
char *get_passwd(const char *pass, const char *desc);
int app_passwd(const char *arg1, const char *arg2, char **pass1, char **pass2);
int add_oid_section(CONF *conf);
X509_REQ *load_csr(const char *file, int format, const char *desc);
X509 *load_cert_pass(const char *uri, int maybe_stdin,
                     const char *pass, const char *desc);
/* the format parameter is meanwhile not needed anymore and thus ignored */
#define load_cert(uri, format, desc) load_cert_pass(uri, 0, NULL, desc)
X509_CRL *load_crl(const char *uri, int format, const char *desc);
void cleanse(char *str);
void clear_free(char *str);
EVP_PKEY *load_key(const char *uri, int format, int maybe_stdin,
                   const char *pass, ENGINE *e, const char *desc);
EVP_PKEY *load_pubkey(const char *uri, int format, int maybe_stdin,
                      const char *pass, ENGINE *e, const char *desc);
int load_certs(const char *uri, STACK_OF(X509) **certs,
               const char *pass, const char *desc);
int load_crls(const char *uri, STACK_OF(X509_CRL) **crls,
              const char *pass, const char *desc);
int load_key_certs_crls(const char *uri, int maybe_stdin,
                        const char *pass, const char *desc,
                        EVP_PKEY **ppkey, EVP_PKEY **ppubkey,
                        X509 **pcert, STACK_OF(X509) **pcerts,
                        X509_CRL **pcrl, STACK_OF(X509_CRL) **pcrls);
int load_key_cert_crl(const char *uri, int maybe_stdin,
                      const char *pass, const char *desc,
                      EVP_PKEY **ppkey, EVP_PKEY **ppubkey,
                      X509 **pcert, X509_CRL **pcrl);
X509_STORE *setup_verify(const char *CAfile, int noCAfile,
                         const char *CApath, int noCApath,
                         const char *CAstore, int noCAstore);
__owur int ctx_set_verify_locations(SSL_CTX *ctx,
                                    const char *CAfile, int noCAfile,
                                    const char *CApath, int noCApath,
                                    const char *CAstore, int noCAstore);

# ifndef OPENSSL_NO_CT

/*
 * Sets the file to load the Certificate Transparency log list from.
 * If path is NULL, loads from the default file path.
 * Returns 1 on success, 0 otherwise.
 */
__owur int ctx_set_ctlog_list_file(SSL_CTX *ctx, const char *path);

# endif

ENGINE *setup_engine_methods(const char *id, unsigned int methods, int debug);
# define setup_engine(e, debug) setup_engine_methods(e, (unsigned int)-1, debug)
void release_engine(ENGINE *e);

# ifndef OPENSSL_NO_OCSP
OCSP_RESPONSE *process_responder(OCSP_REQUEST *req,
                                 const char *host, const char *path,
                                 const char *port, int use_ssl,
                                 STACK_OF(CONF_VALUE) *headers,
                                 int req_timeout);
# endif

/* Functions defined in ca.c and also used in ocsp.c */
int unpack_revinfo(ASN1_TIME **prevtm, int *preason, ASN1_OBJECT **phold,
                   ASN1_GENERALIZEDTIME **pinvtm, const char *str);

# define DB_type         0
# define DB_exp_date     1
# define DB_rev_date     2
# define DB_serial       3      /* index - unique */
# define DB_file         4
# define DB_name         5      /* index - unique when active and not
                                 * disabled */
# define DB_NUMBER       6

# define DB_TYPE_REV     'R'    /* Revoked  */
# define DB_TYPE_EXP     'E'    /* Expired  */
# define DB_TYPE_VAL     'V'    /* Valid ; inserted with: ca ... -valid */
# define DB_TYPE_SUSP    'S'    /* Suspended  */

typedef struct db_attr_st {
    int unique_subject;
} DB_ATTR;
typedef struct ca_db_st {
    DB_ATTR attributes;
    TXT_DB *db;
    char *dbfname;
# ifndef OPENSSL_NO_POSIX_IO
    struct stat dbst;
# endif
} CA_DB;

void app_bail_out(char *fmt, ...);
void* app_malloc(int sz, const char *what);
BIGNUM *load_serial(const char *serialfile, int create, ASN1_INTEGER **retai);
int save_serial(const char *serialfile, const char *suffix, const BIGNUM *serial,
                ASN1_INTEGER **retai);
int rotate_serial(const char *serialfile, const char *new_suffix,
                  const char *old_suffix);
int rand_serial(BIGNUM *b, ASN1_INTEGER *ai);
CA_DB *load_index(const char *dbfile, DB_ATTR *dbattr);
int index_index(CA_DB *db);
int save_index(const char *dbfile, const char *suffix, CA_DB *db);
int rotate_index(const char *dbfile, const char *new_suffix,
                 const char *old_suffix);
void free_index(CA_DB *db);
# define index_name_cmp_noconst(a, b) \
        index_name_cmp((const OPENSSL_CSTRING *)CHECKED_PTR_OF(OPENSSL_STRING, a), \
        (const OPENSSL_CSTRING *)CHECKED_PTR_OF(OPENSSL_STRING, b))
int index_name_cmp(const OPENSSL_CSTRING *a, const OPENSSL_CSTRING *b);
int parse_yesno(const char *str, int def);

X509_NAME *parse_name(const char *str, int chtype, int multirdn,
                      const char *desc);
void policies_print(X509_STORE_CTX *ctx);
int bio_to_mem(unsigned char **out, int maxlen, BIO *in);
int pkey_ctrl_string(EVP_PKEY_CTX *ctx, const char *value);
int x509_ctrl_string(X509 *x, const char *value);
int x509_req_ctrl_string(X509_REQ *x, const char *value);
int init_gen_str(EVP_PKEY_CTX **pctx,
                 const char *algname, ENGINE *e, int do_param,
                 OPENSSL_CTX *libctx, const char *propq);
int do_X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md,
                 STACK_OF(OPENSSL_STRING) *sigopts);
int do_X509_verify(X509 *x, EVP_PKEY *pkey, STACK_OF(OPENSSL_STRING) *vfyopts);
int do_X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md,
                     STACK_OF(OPENSSL_STRING) *sigopts);
int do_X509_REQ_verify(X509_REQ *x, EVP_PKEY *pkey,
                       STACK_OF(OPENSSL_STRING) *vfyopts);
int do_X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md,
                     STACK_OF(OPENSSL_STRING) *sigopts);

extern char *psk_key;


unsigned char *next_protos_parse(size_t *outlen, const char *in);

void print_cert_checks(BIO *bio, X509 *x,
                       const char *checkhost,
                       const char *checkemail, const char *checkip);

void store_setup_crl_download(X509_STORE *st);

typedef struct app_http_tls_info_st {
    const char *server;
    const char *port;
    int use_proxy;
    long timeout;
    SSL_CTX *ssl_ctx;
} APP_HTTP_TLS_INFO;
BIO *app_http_tls_cb(BIO *hbio, /* APP_HTTP_TLS_INFO */ void *arg,
                     int connect, int detail);
# ifndef OPENSSL_NO_SOCK
ASN1_VALUE *app_http_get_asn1(const char *url, const char *proxy,
                              const char *no_proxy, SSL_CTX *ssl_ctx,
                              const STACK_OF(CONF_VALUE) *headers,
                              long timeout, const char *expected_content_type,
                              const ASN1_ITEM *it);
ASN1_VALUE *app_http_post_asn1(const char *host, const char *port,
                               const char *path, const char *proxy,
                               const char *no_proxy, SSL_CTX *ctx,
                               const STACK_OF(CONF_VALUE) *headers,
                               const char *content_type,
                               ASN1_VALUE *req, const ASN1_ITEM *req_it,
                               long timeout, const ASN1_ITEM *rsp_it);
# endif

# define EXT_COPY_NONE   0
# define EXT_COPY_ADD    1
# define EXT_COPY_ALL    2

# define NETSCAPE_CERT_HDR       "certificate"

# define APP_PASS_LEN    1024

/*
 * IETF RFC 5280 says serial number must be <= 20 bytes. Use 159 bits
 * so that the first bit will never be one, so that the DER encoding
 * rules won't force a leading octet.
 */
# define SERIAL_RAND_BITS        159

int app_isdir(const char *);
int app_access(const char *, int flag);
int fileno_stdin(void);
int fileno_stdout(void);
int raw_read_stdin(void *, int);
int raw_write_stdout(const void *, int);

# define TM_START        0
# define TM_STOP         1
double app_tminterval(int stop, int usertime);

void make_uppercase(char *string);

typedef struct verify_options_st {
    int depth;
    int quiet;
    int error;
    int return_error;
} VERIFY_CB_ARGS;

extern VERIFY_CB_ARGS verify_args;

OPENSSL_CTX *app_create_libctx(void);
OPENSSL_CTX *app_get0_libctx(void);
OSSL_PARAM *app_params_new_from_opts(STACK_OF(OPENSSL_STRING) *opts,
                                     const OSSL_PARAM *paramdefs);
void app_params_free(OSSL_PARAM *params);
int app_provider_load(OPENSSL_CTX *libctx, const char *provider_name);
void app_providers_cleanup(void);

OPENSSL_CTX *app_get0_libctx(void);
const char *app_get0_propq(void);

#endif
Commit	Line	Data
846e33c7	1	/*
33388b44	2	* Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
a661b653	3	*
dffa7520	4	* Licensed under the Apache License 2.0 (the "License"). You may not use
846e33c7 RS	5	* this file except in compliance with the License. You can obtain a copy
	6	* in the file LICENSE in the source distribution or at
	7	* https://www.openssl.org/source/license.html
a661b653	8	*/
d02b48c6	9
ae4186b0 DMSP	10	#ifndef OSSL_APPS_H
ae4186b0 DMSP	11	# define OSSL_APPS_H
0f113f3e	12
4cff10dc	13	# include "e_os.h" /* struct timeval for DTLS */
07016a8a	14	# include "internal/nelem.h"
8c10e1b6	15	# include "internal/sockets.h" /* for openssl_fdset() */
3b061a00	16	# include <assert.h>
0f113f3e	17
e306f83c	18	# include <stdarg.h>
3e3c7c36	19	# include <sys/types.h>
c7d5ea26 VD	20	# ifndef OPENSSL_NO_POSIX_IO
	21	# include <sys/stat.h>
	22	# include <fcntl.h>
	23	# endif
	24
568b8020	25	# include <openssl/e_os2.h>
50cd4768	26	# include <openssl/types.h>
0f113f3e MC	27	# include <openssl/bio.h>
0f113f3e MC	28	# include <openssl/x509.h>
0f113f3e MC	29	# include <openssl/conf.h>
0f113f3e MC	30	# include <openssl/txt_db.h>
3c27208f RS	31	# include <openssl/engine.h>
3c27208f RS	32	# include <openssl/ocsp.h>
29f178bd	33	# include <openssl/http.h>
1fbab1dc	34	# include <signal.h>
a43ce58f SL	35	# include "apps_ui.h"
	36	# include "opt.h"
	37	# include "fmt.h"
ce506d27	38	# include "platform.h"
d02b48c6	39
18295f0c RL	40	/*
	41	* quick macro when you need to pass an unsigned char instead of a char.
	42	* this is true for some implementations of the is*() functions, for
	43	* example.
	44	*/
538404d2	45	# define _UC(c) ((unsigned char)(c))
18295f0c	46
3ee1eac2 RS	47	void app_RAND_load_conf(CONF c, const char section);
3ee1eac2 RS	48	void app_RAND_write(void);
a31011e8	49
d02b48c6	50	extern char *default_config_file;
7e1b7485 RS	51	extern BIO *bio_in;
7e1b7485 RS	52	extern BIO *bio_out;
d02b48c6	53	extern BIO *bio_err;
adfc3786 MC	54	extern const unsigned char tls13_aes128gcmsha256_id[];
adfc3786 MC	55	extern const unsigned char tls13_aes256gcmsha384_id[];
10ee7246 MC	56	extern BIO_ADDR *ourpeer;
10ee7246 MC	57
a60994df RL	58	BIO *dup_bio_in(int format);
a60994df RL	59	BIO *dup_bio_out(int format);
149bd5d6	60	BIO *dup_bio_err(int format);
bdd58d98 RL	61	BIO bio_open_owner(const char filename, int format, int private);
	62	BIO bio_open_default(const char filename, char mode, int format);
	63	BIO bio_open_default_quiet(const char filename, char mode, int format);
bfa470a4	64	CONF app_load_config_bio(BIO in, const char *filename);
296f54ee RL	65	CONF app_load_config(const char filename);
	66	CONF app_load_config_quiet(const char filename);
	67	int app_load_modules(const CONF *config);
ae89578b	68	CONF app_load_config_modules(const char configfile);
7e1b7485	69	void unbuffer(FILE *fp);
e1b9840e	70	void wait_for_async(SSL *s);
75dd6c1a MC	71	# if defined(OPENSSL_SYS_MSDOS)
	72	int has_stdin_waiting(void);
	73	# endif
d02b48c6	74
a0754084	75	void corrupt_signature(const ASN1_STRING *signature);
dc047d31 DSH	76	int set_cert_times(X509 x, const char startdate, const char *enddate,
dc047d31 DSH	77	int days);
17ebf85a	78
0f113f3e	79	typedef struct args_st {
7e1b7485 RS	80	int size;
	81	int argc;
	82	char **argv;
0f113f3e	83	} ARGS;
7bf7333d	84
229446df RS	85	/* We need both wrap and the "real" function because libcrypto uses both. */
229446df RS	86	int wrap_password_callback(char buf, int bufsiz, int verify, void cb_data);
2fe5adc3	87
7e1b7485	88	int chopup_args(ARGS arg, char buf);
954ef7ef	89	int dump_cert_text(BIO out, X509 x);
8cc86b81	90	void print_name(BIO out, const char title, const X509_NAME *nm,
0f113f3e	91	unsigned long lflags);
2ac6115d RL	92	void print_bignum_var(BIO , const BIGNUM , const char*,
2ac6115d RL	93	int, unsigned char *);
7e1b7485	94	void print_array(BIO , const char , int, const unsigned char *);
b5c4209b DB	95	int set_nameopt(const char *arg);
b5c4209b DB	96	unsigned long get_nameopt(void);
8ca533e3	97	int set_cert_ex(unsigned long flags, const char arg);
a657546f	98	int set_name_ex(unsigned long flags, const char arg);
791bd0cd DSH	99	int set_ext_copy(int copy_type, const char arg);
791bd0cd DSH	100	int copy_extensions(X509 x, X509_REQ req, int copy_type);
6d382c74	101	char get_passwd(const char pass, const char *desc);
cc696296	102	int app_passwd(const char arg1, const char arg2, char pass1, char pass2);
7e1b7485	103	int add_oid_section(CONF *conf);
9d5aca65	104	X509_REQ load_csr(const char file, int format, const char *desc);
6d382c74 DDO	105	X509 load_cert_pass(const char uri, int maybe_stdin,
	106	const char pass, const char desc);
	107	/* the format parameter is meanwhile not needed anymore and thus ignored */
2a33470b	108	#define load_cert(uri, format, desc) load_cert_pass(uri, 0, NULL, desc)
6d382c74 DDO	109	X509_CRL load_crl(const char uri, int format, const char *desc);
	110	void cleanse(char *str);
	111	void clear_free(char *str);
	112	EVP_PKEY load_key(const char uri, int format, int maybe_stdin,
9d5aca65	113	const char pass, ENGINE e, const char *desc);
6d382c74	114	EVP_PKEY load_pubkey(const char uri, int format, int maybe_stdin,
9d5aca65	115	const char pass, ENGINE e, const char *desc);
b3c5aadf	116	int load_certs(const char uri, STACK_OF(X509) *certs,
9d5aca65	117	const char pass, const char desc);
b3c5aadf	118	int load_crls(const char uri, STACK_OF(X509_CRL) *crls,
9d5aca65	119	const char pass, const char desc);
b3c5aadf DDO	120	int load_key_certs_crls(const char *uri, int maybe_stdin,
	121	const char pass, const char desc,
	122	EVP_PKEY ppkey, EVP_PKEY ppubkey,
	123	X509 pcert, STACK_OF(X509) pcerts,
	124	X509_CRL pcrl, STACK_OF(X509_CRL) pcrls);
6d382c74 DDO	125	int load_key_cert_crl(const char *uri, int maybe_stdin,
6d382c74 DDO	126	const char pass, const char desc,
2274d22d RL	127	EVP_PKEY ppkey, EVP_PKEY ppubkey,
2274d22d RL	128	X509 pcert, X509_CRL pcrl);
fd3397fc RL	129	X509_STORE setup_verify(const char CAfile, int noCAfile,
	130	const char *CApath, int noCApath,
	131	const char *CAstore, int noCAstore);
	132	__owur int ctx_set_verify_locations(SSL_CTX *ctx,
	133	const char *CAfile, int noCAfile,
	134	const char *CApath, int noCApath,
	135	const char *CAstore, int noCAstore);
ca74c38d	136
538404d2	137	# ifndef OPENSSL_NO_CT
b5369582	138
ca74c38d RP	139	/*
	140	* Sets the file to load the Certificate Transparency log list from.
	141	* If path is NULL, loads from the default file path.
	142	* Returns 1 on success, 0 otherwise.
	143	*/
5da65ef2	144	__owur int ctx_set_ctlog_list_file(SSL_CTX ctx, const char path);
dd696a55	145
538404d2	146	# endif
b5369582	147
538404d2 DO	148	ENGINE setup_engine_methods(const char id, unsigned int methods, int debug);
538404d2 DO	149	# define setup_engine(e, debug) setup_engine_methods(e, (unsigned int)-1, debug)
dd1abd44	150	void release_engine(ENGINE *e);
907c6c86	151
0f113f3e	152	# ifndef OPENSSL_NO_OCSP
7e1b7485	153	OCSP_RESPONSE process_responder(OCSP_REQUEST req,
0f113f3e MC	154	const char host, const char path,
0f113f3e MC	155	const char *port, int use_ssl,
82c49427	156	STACK_OF(CONF_VALUE) *headers,
0f113f3e MC	157	int req_timeout);
0f113f3e MC	158	# endif
67c8e7f4	159
ee306a13 DSH	160	/* Functions defined in ca.c and also used in ocsp.c */
ee306a13 DSH	161	int unpack_revinfo(ASN1_TIME *prevtm, int preason, ASN1_OBJECT **phold,
0f113f3e MC	162	ASN1_GENERALIZEDTIME *pinvtm, const char str);
	163
	164	# define DB_type 0
	165	# define DB_exp_date 1
	166	# define DB_rev_date 2
	167	# define DB_serial 3 /* index - unique */
	168	# define DB_file 4
	169	# define DB_name 5 /* index - unique when active and not
	170	* disabled */
	171	# define DB_NUMBER 6
	172
06a79af2 F	173	# define DB_TYPE_REV 'R' /* Revoked */
	174	# define DB_TYPE_EXP 'E' /* Expired */
	175	# define DB_TYPE_VAL 'V' /* Valid ; inserted with: ca ... -valid */
	176	# define DB_TYPE_SUSP 'S' /* Suspended */
0f113f3e MC	177
	178	typedef struct db_attr_st {
	179	int unique_subject;
	180	} DB_ATTR;
	181	typedef struct ca_db_st {
	182	DB_ATTR attributes;
	183	TXT_DB *db;
c7d5ea26 VD	184	char *dbfname;
	185	# ifndef OPENSSL_NO_POSIX_IO
	186	struct stat dbst;
	187	# endif
0f113f3e	188	} CA_DB;
f85b68cd	189
e306f83c	190	void app_bail_out(char *fmt, ...);
68dc6824	191	void* app_malloc(int sz, const char *what);
cc696296 F	192	BIGNUM load_serial(const char serialfile, int create, ASN1_INTEGER **retai);
cc696296 F	193	int save_serial(const char serialfile, const char suffix, const BIGNUM *serial,
0f113f3e	194	ASN1_INTEGER **retai);
cc696296 F	195	int rotate_serial(const char serialfile, const char new_suffix,
cc696296 F	196	const char *old_suffix);
64674bcc	197	int rand_serial(BIGNUM b, ASN1_INTEGER ai);
cc696296	198	CA_DB load_index(const char dbfile, DB_ATTR *dbattr);
f85b68cd	199	int index_index(CA_DB *db);
7d727231	200	int save_index(const char dbfile, const char suffix, CA_DB *db);
0f113f3e MC	201	int rotate_index(const char dbfile, const char new_suffix,
0f113f3e MC	202	const char *old_suffix);
f85b68cd	203	void free_index(CA_DB *db);
0f113f3e MC	204	# define index_name_cmp_noconst(a, b) \
	205	index_name_cmp((const OPENSSL_CSTRING *)CHECKED_PTR_OF(OPENSSL_STRING, a), \
	206	(const OPENSSL_CSTRING *)CHECKED_PTR_OF(OPENSSL_STRING, b))
c869da88	207	int index_name_cmp(const OPENSSL_CSTRING a, const OPENSSL_CSTRING b);
ff990440	208	int parse_yesno(const char *str, int def);
ee306a13	209
57c05c57 DDO	210	X509_NAME parse_name(const char str, int chtype, int multirdn,
57c05c57 DDO	211	const char *desc);
ecf3a1fb	212	void policies_print(X509_STORE_CTX *ctx);
a9164153	213	int bio_to_mem(unsigned char *out, int maxlen, BIO in);
0c20802c	214	int pkey_ctrl_string(EVP_PKEY_CTX ctx, const char value);
aba9bca3 RL	215	int x509_ctrl_string(X509 x, const char value);
aba9bca3 RL	216	int x509_req_ctrl_string(X509_REQ x, const char value);
7e1b7485	217	int init_gen_str(EVP_PKEY_CTX **pctx,
7c9a7cf1 SL	218	const char algname, ENGINE e, int do_param,
7c9a7cf1 SL	219	OPENSSL_CTX libctx, const char propq);
7e1b7485	220	int do_X509_sign(X509 x, EVP_PKEY pkey, const EVP_MD *md,
0f113f3e	221	STACK_OF(OPENSSL_STRING) *sigopts);
2292c8e1	222	int do_X509_verify(X509 x, EVP_PKEY pkey, STACK_OF(OPENSSL_STRING) *vfyopts);
7e1b7485	223	int do_X509_REQ_sign(X509_REQ x, EVP_PKEY pkey, const EVP_MD *md,
0f113f3e	224	STACK_OF(OPENSSL_STRING) *sigopts);
aba9bca3 RL	225	int do_X509_REQ_verify(X509_REQ x, EVP_PKEY pkey,
aba9bca3 RL	226	STACK_OF(OPENSSL_STRING) *vfyopts);
7e1b7485	227	int do_X509_CRL_sign(X509_CRL x, EVP_PKEY pkey, const EVP_MD *md,
0f113f3e	228	STACK_OF(OPENSSL_STRING) *sigopts);
14e35350	229
f3b7bdad	230	extern char *psk_key;
14e35350	231
eee6c81a	232
817cd0d5	233	unsigned char next_protos_parse(size_t outlen, const char *in);
71fa4513	234
a70da5b3	235	void print_cert_checks(BIO bio, X509 x,
0f113f3e MC	236	const char *checkhost,
0f113f3e MC	237	const char checkemail, const char checkip);
a70da5b3	238
0090a686 DSH	239	void store_setup_crl_download(X509_STORE *st);
0090a686 DSH	240
29f178bd DDO	241	typedef struct app_http_tls_info_st {
	242	const char *server;
	243	const char *port;
	244	int use_proxy;
	245	long timeout;
	246	SSL_CTX *ssl_ctx;
	247	} APP_HTTP_TLS_INFO;
	248	BIO app_http_tls_cb(BIO hbio, /* APP_HTTP_TLS_INFO / void arg,
	249	int connect, int detail);
	250	# ifndef OPENSSL_NO_SOCK
	251	ASN1_VALUE app_http_get_asn1(const char url, const char *proxy,
afe554c2	252	const char no_proxy, SSL_CTX ssl_ctx,
29f178bd DDO	253	const STACK_OF(CONF_VALUE) *headers,
	254	long timeout, const char *expected_content_type,
	255	const ASN1_ITEM *it);
	256	ASN1_VALUE app_http_post_asn1(const char host, const char *port,
	257	const char path, const char proxy,
afe554c2	258	const char no_proxy, SSL_CTX ctx,
29f178bd DDO	259	const STACK_OF(CONF_VALUE) *headers,
	260	const char *content_type,
	261	ASN1_VALUE req, const ASN1_ITEM req_it,
	262	long timeout, const ASN1_ITEM *rsp_it);
	263	# endif
	264
0f113f3e MC	265	# define EXT_COPY_NONE 0
	266	# define EXT_COPY_ADD 1
	267	# define EXT_COPY_ALL 2
	268
	269	# define NETSCAPE_CERT_HDR "certificate"
	270
	271	# define APP_PASS_LEN 1024
	272
ffb46830 RS	273	/*
	274	* IETF RFC 5280 says serial number must be <= 20 bytes. Use 159 bits
	275	* so that the first bit will never be one, so that the DER encoding
	276	* rules won't force a leading octet.
	277	*/
	278	# define SERIAL_RAND_BITS 159
64674bcc	279
ffa10187	280	int app_isdir(const char *);
7e1b7485	281	int app_access(const char *, int flag);
51e5133d RL	282	int fileno_stdin(void);
51e5133d RL	283	int fileno_stdout(void);
0f113f3e MC	284	int raw_read_stdin(void *, int);
0f113f3e MC	285	int raw_write_stdout(const void *, int);
0a39d8f2	286
0f113f3e MC	287	# define TM_START 0
	288	# define TM_STOP 1
	289	double app_tminterval(int stop, int usertime);
ee2ffc27	290
20967afb RS	291	void make_uppercase(char *string);
20967afb RS	292
acc00492 F	293	typedef struct verify_options_st {
	294	int depth;
	295	int quiet;
	296	int error;
	297	int return_error;
	298	} VERIFY_CB_ARGS;
	299
	300	extern VERIFY_CB_ARGS verify_args;
df2ee0e2	301
ae89578b SL	302	OPENSSL_CTX *app_create_libctx(void);
ae89578b SL	303	OPENSSL_CTX *app_get0_libctx(void);
95214b43 SL	304	OSSL_PARAM app_params_new_from_opts(STACK_OF(OPENSSL_STRING) opts,
	305	const OSSL_PARAM *paramdefs);
	306	void app_params_free(OSSL_PARAM *params);
ae89578b	307	int app_provider_load(OPENSSL_CTX libctx, const char provider_name);
f5056577	308	void app_providers_cleanup(void);
95214b43	309
6725682d SL	310	OPENSSL_CTX *app_get0_libctx(void);
	311	const char *app_get0_propq(void);
	312
ee2ffc27	313	#endif