[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);
int set_crl_lastupdate(X509_CRL *crl, const char *lastupdate);
int set_crl_nextupdate(X509_CRL *crl, const char *nextupdate,
                       long days, long hours, long secs);

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);
int init_engine(ENGINE *e);
int finish_engine(ENGINE *e);
EVP_PKEY *load_engine_private_key(ENGINE *e, const char *keyid,
                                  const char *pass, const char *desc);
EVP_PKEY *load_engine_public_key(ENGINE *e, const char *keyid,
                                 const char *pass, const char *desc);

# 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);
64713cb1 CN	78	int set_crl_lastupdate(X509_CRL crl, const char lastupdate);
	79	int set_crl_nextupdate(X509_CRL crl, const char nextupdate,
	80	long days, long hours, long secs);
17ebf85a	81
0f113f3e	82	typedef struct args_st {
7e1b7485 RS	83	int size;
	84	int argc;
	85	char **argv;
0f113f3e	86	} ARGS;
7bf7333d	87
229446df RS	88	/* We need both wrap and the "real" function because libcrypto uses both. */
229446df RS	89	int wrap_password_callback(char buf, int bufsiz, int verify, void cb_data);
2fe5adc3	90
7e1b7485	91	int chopup_args(ARGS arg, char buf);
954ef7ef	92	int dump_cert_text(BIO out, X509 x);
8cc86b81	93	void print_name(BIO out, const char title, const X509_NAME *nm,
0f113f3e	94	unsigned long lflags);
2ac6115d RL	95	void print_bignum_var(BIO , const BIGNUM , const char*,
2ac6115d RL	96	int, unsigned char *);
7e1b7485	97	void print_array(BIO , const char , int, const unsigned char *);
b5c4209b DB	98	int set_nameopt(const char *arg);
b5c4209b DB	99	unsigned long get_nameopt(void);
8ca533e3	100	int set_cert_ex(unsigned long flags, const char arg);
a657546f	101	int set_name_ex(unsigned long flags, const char arg);
791bd0cd DSH	102	int set_ext_copy(int copy_type, const char arg);
791bd0cd DSH	103	int copy_extensions(X509 x, X509_REQ req, int copy_type);
6d382c74	104	char get_passwd(const char pass, const char *desc);
cc696296	105	int app_passwd(const char arg1, const char arg2, char pass1, char pass2);
7e1b7485	106	int add_oid_section(CONF *conf);
9d5aca65	107	X509_REQ load_csr(const char file, int format, const char *desc);
6d382c74 DDO	108	X509 load_cert_pass(const char uri, int maybe_stdin,
	109	const char pass, const char desc);
	110	/* the format parameter is meanwhile not needed anymore and thus ignored */
2a33470b	111	#define load_cert(uri, format, desc) load_cert_pass(uri, 0, NULL, desc)
6d382c74 DDO	112	X509_CRL load_crl(const char uri, int format, const char *desc);
	113	void cleanse(char *str);
	114	void clear_free(char *str);
	115	EVP_PKEY load_key(const char uri, int format, int maybe_stdin,
9d5aca65	116	const char pass, ENGINE e, const char *desc);
6d382c74	117	EVP_PKEY load_pubkey(const char uri, int format, int maybe_stdin,
9d5aca65	118	const char pass, ENGINE e, const char *desc);
b3c5aadf	119	int load_certs(const char uri, STACK_OF(X509) *certs,
9d5aca65	120	const char pass, const char desc);
b3c5aadf	121	int load_crls(const char uri, STACK_OF(X509_CRL) *crls,
9d5aca65	122	const char pass, const char desc);
b3c5aadf DDO	123	int load_key_certs_crls(const char *uri, int maybe_stdin,
	124	const char pass, const char desc,
	125	EVP_PKEY ppkey, EVP_PKEY ppubkey,
	126	X509 pcert, STACK_OF(X509) pcerts,
	127	X509_CRL pcrl, STACK_OF(X509_CRL) pcrls);
6d382c74 DDO	128	int load_key_cert_crl(const char *uri, int maybe_stdin,
6d382c74 DDO	129	const char pass, const char desc,
2274d22d RL	130	EVP_PKEY ppkey, EVP_PKEY ppubkey,
2274d22d RL	131	X509 pcert, X509_CRL pcrl);
fd3397fc RL	132	X509_STORE setup_verify(const char CAfile, int noCAfile,
	133	const char *CApath, int noCApath,
	134	const char *CAstore, int noCAstore);
	135	__owur int ctx_set_verify_locations(SSL_CTX *ctx,
	136	const char *CAfile, int noCAfile,
	137	const char *CApath, int noCApath,
	138	const char *CAstore, int noCAstore);
ca74c38d	139
538404d2	140	# ifndef OPENSSL_NO_CT
b5369582	141
ca74c38d RP	142	/*
	143	* Sets the file to load the Certificate Transparency log list from.
	144	* If path is NULL, loads from the default file path.
	145	* Returns 1 on success, 0 otherwise.
	146	*/
5da65ef2	147	__owur int ctx_set_ctlog_list_file(SSL_CTX ctx, const char path);
dd696a55	148
538404d2	149	# endif
b5369582	150
538404d2 DO	151	ENGINE setup_engine_methods(const char id, unsigned int methods, int debug);
538404d2 DO	152	# define setup_engine(e, debug) setup_engine_methods(e, (unsigned int)-1, debug)
dd1abd44	153	void release_engine(ENGINE *e);
6514dee7 RL	154	int init_engine(ENGINE *e);
	155	int finish_engine(ENGINE *e);
	156	EVP_PKEY load_engine_private_key(ENGINE e, const char *keyid,
	157	const char pass, const char desc);
	158	EVP_PKEY load_engine_public_key(ENGINE e, const char *keyid,
	159	const char pass, const char desc);
907c6c86	160
0f113f3e	161	# ifndef OPENSSL_NO_OCSP
7e1b7485	162	OCSP_RESPONSE process_responder(OCSP_REQUEST req,
0f113f3e MC	163	const char host, const char path,
0f113f3e MC	164	const char *port, int use_ssl,
82c49427	165	STACK_OF(CONF_VALUE) *headers,
0f113f3e MC	166	int req_timeout);
0f113f3e MC	167	# endif
67c8e7f4	168
ee306a13 DSH	169	/* Functions defined in ca.c and also used in ocsp.c */
ee306a13 DSH	170	int unpack_revinfo(ASN1_TIME *prevtm, int preason, ASN1_OBJECT **phold,
0f113f3e MC	171	ASN1_GENERALIZEDTIME *pinvtm, const char str);
	172
	173	# define DB_type 0
	174	# define DB_exp_date 1
	175	# define DB_rev_date 2
	176	# define DB_serial 3 /* index - unique */
	177	# define DB_file 4
	178	# define DB_name 5 /* index - unique when active and not
	179	* disabled */
	180	# define DB_NUMBER 6
	181
06a79af2 F	182	# define DB_TYPE_REV 'R' /* Revoked */
	183	# define DB_TYPE_EXP 'E' /* Expired */
	184	# define DB_TYPE_VAL 'V' /* Valid ; inserted with: ca ... -valid */
	185	# define DB_TYPE_SUSP 'S' /* Suspended */
0f113f3e MC	186
	187	typedef struct db_attr_st {
	188	int unique_subject;
	189	} DB_ATTR;
	190	typedef struct ca_db_st {
	191	DB_ATTR attributes;
	192	TXT_DB *db;
c7d5ea26 VD	193	char *dbfname;
	194	# ifndef OPENSSL_NO_POSIX_IO
	195	struct stat dbst;
	196	# endif
0f113f3e	197	} CA_DB;
f85b68cd	198
e306f83c	199	void app_bail_out(char *fmt, ...);
68dc6824	200	void* app_malloc(int sz, const char *what);
cc696296 F	201	BIGNUM load_serial(const char serialfile, int create, ASN1_INTEGER **retai);
cc696296 F	202	int save_serial(const char serialfile, const char suffix, const BIGNUM *serial,
0f113f3e	203	ASN1_INTEGER **retai);
cc696296 F	204	int rotate_serial(const char serialfile, const char new_suffix,
cc696296 F	205	const char *old_suffix);
64674bcc	206	int rand_serial(BIGNUM b, ASN1_INTEGER ai);
cc696296	207	CA_DB load_index(const char dbfile, DB_ATTR *dbattr);
f85b68cd	208	int index_index(CA_DB *db);
7d727231	209	int save_index(const char dbfile, const char suffix, CA_DB *db);
0f113f3e MC	210	int rotate_index(const char dbfile, const char new_suffix,
0f113f3e MC	211	const char *old_suffix);
f85b68cd	212	void free_index(CA_DB *db);
0f113f3e MC	213	# define index_name_cmp_noconst(a, b) \
	214	index_name_cmp((const OPENSSL_CSTRING *)CHECKED_PTR_OF(OPENSSL_STRING, a), \
	215	(const OPENSSL_CSTRING *)CHECKED_PTR_OF(OPENSSL_STRING, b))
c869da88	216	int index_name_cmp(const OPENSSL_CSTRING a, const OPENSSL_CSTRING b);
ff990440	217	int parse_yesno(const char *str, int def);
ee306a13	218
57c05c57 DDO	219	X509_NAME parse_name(const char str, int chtype, int multirdn,
57c05c57 DDO	220	const char *desc);
ecf3a1fb	221	void policies_print(X509_STORE_CTX *ctx);
a9164153	222	int bio_to_mem(unsigned char *out, int maxlen, BIO in);
0c20802c	223	int pkey_ctrl_string(EVP_PKEY_CTX ctx, const char value);
aba9bca3 RL	224	int x509_ctrl_string(X509 x, const char value);
aba9bca3 RL	225	int x509_req_ctrl_string(X509_REQ x, const char value);
7e1b7485	226	int init_gen_str(EVP_PKEY_CTX **pctx,
7c9a7cf1 SL	227	const char algname, ENGINE e, int do_param,
7c9a7cf1 SL	228	OPENSSL_CTX libctx, const char propq);
7e1b7485	229	int do_X509_sign(X509 x, EVP_PKEY pkey, const EVP_MD *md,
0f113f3e	230	STACK_OF(OPENSSL_STRING) *sigopts);
2292c8e1	231	int do_X509_verify(X509 x, EVP_PKEY pkey, STACK_OF(OPENSSL_STRING) *vfyopts);
7e1b7485	232	int do_X509_REQ_sign(X509_REQ x, EVP_PKEY pkey, const EVP_MD *md,
0f113f3e	233	STACK_OF(OPENSSL_STRING) *sigopts);
aba9bca3 RL	234	int do_X509_REQ_verify(X509_REQ x, EVP_PKEY pkey,
aba9bca3 RL	235	STACK_OF(OPENSSL_STRING) *vfyopts);
7e1b7485	236	int do_X509_CRL_sign(X509_CRL x, EVP_PKEY pkey, const EVP_MD *md,
0f113f3e	237	STACK_OF(OPENSSL_STRING) *sigopts);
14e35350	238
f3b7bdad	239	extern char *psk_key;
14e35350	240
eee6c81a	241
817cd0d5	242	unsigned char next_protos_parse(size_t outlen, const char *in);
71fa4513	243
a70da5b3	244	void print_cert_checks(BIO bio, X509 x,
0f113f3e MC	245	const char *checkhost,
0f113f3e MC	246	const char checkemail, const char checkip);
a70da5b3	247
0090a686 DSH	248	void store_setup_crl_download(X509_STORE *st);
0090a686 DSH	249
29f178bd DDO	250	typedef struct app_http_tls_info_st {
	251	const char *server;
	252	const char *port;
	253	int use_proxy;
	254	long timeout;
	255	SSL_CTX *ssl_ctx;
	256	} APP_HTTP_TLS_INFO;
	257	BIO app_http_tls_cb(BIO hbio, /* APP_HTTP_TLS_INFO / void arg,
	258	int connect, int detail);
	259	# ifndef OPENSSL_NO_SOCK
	260	ASN1_VALUE app_http_get_asn1(const char url, const char *proxy,
afe554c2	261	const char no_proxy, SSL_CTX ssl_ctx,
29f178bd DDO	262	const STACK_OF(CONF_VALUE) *headers,
	263	long timeout, const char *expected_content_type,
	264	const ASN1_ITEM *it);
	265	ASN1_VALUE app_http_post_asn1(const char host, const char *port,
	266	const char path, const char proxy,
afe554c2	267	const char no_proxy, SSL_CTX ctx,
29f178bd DDO	268	const STACK_OF(CONF_VALUE) *headers,
	269	const char *content_type,
	270	ASN1_VALUE req, const ASN1_ITEM req_it,
	271	long timeout, const ASN1_ITEM *rsp_it);
	272	# endif
	273
0f113f3e MC	274	# define EXT_COPY_NONE 0
	275	# define EXT_COPY_ADD 1
	276	# define EXT_COPY_ALL 2
	277
	278	# define NETSCAPE_CERT_HDR "certificate"
	279
	280	# define APP_PASS_LEN 1024
	281
ffb46830 RS	282	/*
	283	* IETF RFC 5280 says serial number must be <= 20 bytes. Use 159 bits
	284	* so that the first bit will never be one, so that the DER encoding
	285	* rules won't force a leading octet.
	286	*/
	287	# define SERIAL_RAND_BITS 159
64674bcc	288
ffa10187	289	int app_isdir(const char *);
7e1b7485	290	int app_access(const char *, int flag);
51e5133d RL	291	int fileno_stdin(void);
51e5133d RL	292	int fileno_stdout(void);
0f113f3e MC	293	int raw_read_stdin(void *, int);
0f113f3e MC	294	int raw_write_stdout(const void *, int);
0a39d8f2	295
0f113f3e MC	296	# define TM_START 0
	297	# define TM_STOP 1
	298	double app_tminterval(int stop, int usertime);
ee2ffc27	299
20967afb RS	300	void make_uppercase(char *string);
20967afb RS	301
acc00492 F	302	typedef struct verify_options_st {
	303	int depth;
	304	int quiet;
	305	int error;
	306	int return_error;
	307	} VERIFY_CB_ARGS;
	308
	309	extern VERIFY_CB_ARGS verify_args;
df2ee0e2	310
ae89578b SL	311	OPENSSL_CTX *app_create_libctx(void);
ae89578b SL	312	OPENSSL_CTX *app_get0_libctx(void);
95214b43 SL	313	OSSL_PARAM app_params_new_from_opts(STACK_OF(OPENSSL_STRING) opts,
	314	const OSSL_PARAM *paramdefs);
	315	void app_params_free(OSSL_PARAM *params);
ae89578b	316	int app_provider_load(OPENSSL_CTX libctx, const char provider_name);
f5056577	317	void app_providers_cleanup(void);
95214b43	318
6725682d SL	319	OPENSSL_CTX *app_get0_libctx(void);
	320	const char *app_get0_propq(void);
	321
ee2ffc27	322	#endif