gnutls-openssl.htmlPrev ch01.htmlUp index.htmlHome GNU TLS API Reference Manual gnutls-libtasn1.htmlNext #top_of_pageTop                    | 
                  
#descDescription opencdk
opencdk — 
Synopsis
#define     
gnutls-opencdk.html#OPENCDK-VERSION:CAPSOPENCDK_VERSION struct      
gnutls-opencdk.html#cdk-ctx-scdk_ctx_s ;
typedef     
gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t ;
struct      
gnutls-opencdk.html#cdk-strlist-scdk_strlist_s ;
typedef     
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t ;
struct      
gnutls-opencdk.html#cdk-sesskey-scdk_sesskey_s ;
typedef     
gnutls-opencdk.html#cdk-sesskey-tcdk_sesskey_t ;
struct      
gnutls-opencdk.html#cdk-listkey-scdk_listkey_s ;
typedef     
gnutls-opencdk.html#cdk-listkey-tcdk_listkey_t ;
struct      
gnutls-opencdk.html#cdk-mpi-scdk_mpi_s ;
typedef     
gnutls-opencdk.html#cdk-mpi-tcdk_mpi_t ;
struct      
gnutls-opencdk.html#cdk-dek-scdk_dek_s ;
typedef     
gnutls-opencdk.html#cdk-dek-tcdk_dek_t ;
struct      
gnutls-opencdk.html#cdk-s2k-scdk_s2k_s ;
typedef     
gnutls-opencdk.html#cdk-s2k-tcdk_s2k_t ;
struct      
gnutls-opencdk.html#cdk-stream-scdk_stream_s ;
typedef     
gnutls-opencdk.html#cdk-stream-tcdk_stream_t ;
struct      
gnutls-opencdk.html#cdk-prefitem-scdk_prefitem_s ;
typedef     
gnutls-opencdk.html#cdk-prefitem-tcdk_prefitem_t ;
struct      
gnutls-opencdk.html#cdk-kbnode-scdk_kbnode_s ;
typedef     
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t ;
struct      
gnutls-opencdk.html#cdk-keydb-hd-scdk_keydb_hd_s ;
typedef     
gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t ;
struct      
gnutls-opencdk.html#cdk-keylist-scdk_keylist_s ;
typedef     
gnutls-opencdk.html#cdk-keylist-tcdk_keylist_t ;
struct      
gnutls-opencdk.html#cdk-subpkt-scdk_subpkt_s ;
typedef     
gnutls-opencdk.html#cdk-subpkt-tcdk_subpkt_t ;
struct      
gnutls-opencdk.html#cdk-keygen-ctx-scdk_keygen_ctx_s ;
typedef     
gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t ;
struct      
gnutls-opencdk.html#cdk-desig-revoker-scdk_desig_revoker_s ;
typedef     
gnutls-opencdk.html#cdk-desig-revoker-tcdk_desig_revoker_t ;
struct      
gnutls-opencdk.html#cdk-md-hd-scdk_md_hd_s ;
typedef     
gnutls-opencdk.html#cdk-md-hd-tcdk_md_hd_t ;
struct      
gnutls-opencdk.html#cdk-cipher-hd-scdk_cipher_hd_s ;
typedef     
gnutls-opencdk.html#cdk-cipher-hd-tcdk_cipher_hd_t ;
enum        
gnutls-opencdk.html#cdk-error-tcdk_error_t ;
enum        
gnutls-opencdk.html#cdk-packet-type-tcdk_packet_type_t ;
struct      
gnutls-opencdk.html#cdk-pkt-userid-scdk_pkt_userid_s ;
typedef     
gnutls-opencdk.html#cdk-pkt-userid-tcdk_pkt_userid_t ;
struct      
gnutls-opencdk.html#cdk-pkt-pubkey-scdk_pkt_pubkey_s ;
typedef     
gnutls-opencdk.html#cdk-pkt-pubkey-tcdk_pkt_pubkey_t ;
struct      
gnutls-opencdk.html#cdk-pkt-seckey-scdk_pkt_seckey_s ;
typedef     
gnutls-opencdk.html#cdk-pkt-seckey-tcdk_pkt_seckey_t ;
struct      
gnutls-opencdk.html#cdk-pkt-signature-scdk_pkt_signature_s ;
typedef     
gnutls-opencdk.html#cdk-pkt-signature-tcdk_pkt_signature_t ;
struct      
gnutls-opencdk.html#cdk-pkt-onepass-sig-scdk_pkt_onepass_sig_s ;
typedef     
gnutls-opencdk.html#cdk-pkt-onepass-sig-tcdk_pkt_onepass_sig_t ;
struct      
gnutls-opencdk.html#cdk-pkt-pubkey-enc-scdk_pkt_pubkey_enc_s ;
typedef     
gnutls-opencdk.html#cdk-pkt-pubkey-enc-tcdk_pkt_pubkey_enc_t ;
struct      
gnutls-opencdk.html#cdk-pkt-symkey-enc-scdk_pkt_symkey_enc_s ;
typedef     
gnutls-opencdk.html#cdk-pkt-symkey-enc-tcdk_pkt_symkey_enc_t ;
struct      
gnutls-opencdk.html#cdk-pkt-encrypted-scdk_pkt_encrypted_s ;
typedef     
gnutls-opencdk.html#cdk-pkt-encrypted-tcdk_pkt_encrypted_t ;
struct      
gnutls-opencdk.html#cdk-pkt-mdc-scdk_pkt_mdc_s ;
typedef     
gnutls-opencdk.html#cdk-pkt-mdc-tcdk_pkt_mdc_t ;
struct      
gnutls-opencdk.html#cdk-pkt-literal-scdk_pkt_literal_s ;
typedef     
gnutls-opencdk.html#cdk-pkt-literal-tcdk_pkt_literal_t ;
struct      
gnutls-opencdk.html#cdk-pkt-compressed-scdk_pkt_compressed_s ;
typedef     
gnutls-opencdk.html#cdk-pkt-compressed-tcdk_pkt_compressed_t ;
struct      
gnutls-opencdk.html#cdk-packet-scdk_packet_s ;
typedef     
gnutls-opencdk.html#CDK-PACKET:CAPSCDK_PACKET ;
typedef     
gnutls-opencdk.html#cdk-packet-tcdk_packet_t ;
../gss/gss-ext.html#voidvoid         ( gnutls-opencdk.html#cdk-log-fnc-t*cdk_log_fnc_t )                ( ../gss/gss-ext.html#voidvoid *,
                                             ...,
                                             const char*,
                                             va_list);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-set-log-levelcdk_set_log_level                (int lvl);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-set-log-handlercdk_set_log_handler              ( gnutls-opencdk.html#cdk-log-fnc-tcdk_log_fnc_t  logfnc,
                                             
../gss/gss-ext.html#voidvoid  *opaq);
const char* 
gnutls-opencdk.html#cdk-strerrorcdk_strerror                     (int ec);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-set-malloc-hookscdk_set_malloc_hooks             ( ../gss/gss-ext.html#voidvoid * (*new_alloc_func) (size_t n),
                                             
../gss/gss-ext.html#voidvoid * (*new_alloc_secure_func) (size_t n),
                                             
../gss/gss-ext.html#voidvoid * (*new_realloc_func) (void * p, size_t n),
                                             
../gss/gss-ext.html#voidvoid * (*new_calloc_func) (size_t m, size_t n),
                                             
../gss/gss-ext.html#voidvoid  (*new_free_func) (void *));
int         
gnutls-opencdk.html#cdk-malloc-hook-initializedcdk_malloc_hook_initialized      (void);
../gss/gss-ext.html#voidvoid *       gnutls-opencdk.html#cdk-malloccdk_malloc                       (size_t size);
../gss/gss-ext.html#voidvoid *       gnutls-opencdk.html#cdk-calloccdk_calloc                       (size_t n,
                                             size_t m);
../gss/gss-ext.html#voidvoid *       gnutls-opencdk.html#cdk-realloccdk_realloc                      ( ../gss/gss-ext.html#voidvoid  *ptr,
                                             size_t size);
../gss/gss-ext.html#voidvoid *       gnutls-opencdk.html#cdk-salloccdk_salloc                       (size_t size,
                                             int clear);
char*       
gnutls-opencdk.html#cdk-strdupcdk_strdup                       (const char *ptr);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-freecdk_free                         ( ../gss/gss-ext.html#voidvoid  *ptr);
int         
gnutls-opencdk.html#cdk-handle-newcdk_handle_new                   ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  *r_ctx);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-handle-freecdk_handle_free                  ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  c);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-handle-set-keydbcdk_handle_set_keydb             ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             
gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  db);
gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  gnutls-opencdk.html#cdk-handle-get-keydbcdk_handle_get_keydb          ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             int type);
int         
gnutls-opencdk.html#cdk-handle-controlcdk_handle_control               ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             int action,
                                             int cmd,
                                             ...);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-handle-set-callbackcdk_handle_set_callback          ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             
../gss/gss-ext.html#voidvoid  (*cb) (void *opa, int type, const char * s),
                                             
../gss/gss-ext.html#voidvoid  *cb_value);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-handle-set-passphrase-cbcdk_handle_set_passphrase_cb     ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             char* (*cb) (void *opa, const char *prompt),
                                             
../gss/gss-ext.html#voidvoid  *cb_value);
#define     
gnutls-opencdk.html#cdk-handle-set-armorcdk_handle_set_armor             ( a, val )
#define     
gnutls-opencdk.html#cdk-handle-set-compresscdk_handle_set_compress          ( a, algo, level )
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-set-progress-handlercdk_set_progress_handler         ( ../gss/gss-ext.html#voidvoid  (*cb) (void * hd, unsigned off,unsigned size),
                                             
../gss/gss-ext.html#voidvoid  *cb_value);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-pkt-newcdk_pkt_new                      ( gnutls-opencdk.html#cdk-packet-tcdk_packet_t  *r_pkt);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-pkt-initcdk_pkt_init                     ( gnutls-opencdk.html#cdk-packet-tcdk_packet_t  pkt);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-pkt-alloccdk_pkt_alloc                    ( gnutls-opencdk.html#cdk-packet-tcdk_packet_t  *r_pkt,
                                             int pkttype);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-pkt-freecdk_pkt_free                     ( gnutls-opencdk.html#cdk-packet-tcdk_packet_t  pkt);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-pkt-releasecdk_pkt_release                  ( gnutls-opencdk.html#cdk-packet-tcdk_packet_t  pkt);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-pkt-readcdk_pkt_read                     ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  inp,
                                             
gnutls-opencdk.html#cdk-packet-tcdk_packet_t  pkt);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-pkt-writecdk_pkt_write                    ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  out,
                                             
gnutls-opencdk.html#cdk-packet-tcdk_packet_t  pkt);
gnutls-opencdk.html#cdk-subpkt-tcdk_subpkt_t  gnutls-opencdk.html#cdk-subpkt-newcdk_subpkt_new                  (size_t size);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-subpkt-freecdk_subpkt_free                  ( gnutls-opencdk.html#cdk-subpkt-tcdk_subpkt_t  ctx);
gnutls-opencdk.html#cdk-subpkt-tcdk_subpkt_t  gnutls-opencdk.html#cdk-subpkt-findcdk_subpkt_find                 ( gnutls-opencdk.html#cdk-subpkt-tcdk_subpkt_t  ctx,
                                             int type);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-subpkt-addcdk_subpkt_add                   ( gnutls-opencdk.html#cdk-subpkt-tcdk_subpkt_t  root,
                                             
gnutls-opencdk.html#cdk-subpkt-tcdk_subpkt_t  node);
const unsigned char* 
gnutls-opencdk.html#cdk-subpkt-get-datacdk_subpkt_get_data     ( gnutls-opencdk.html#cdk-subpkt-tcdk_subpkt_t  ctx,
                                             int *r_type,
                                             size_t *r_nbytes);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-subpkt-initcdk_subpkt_init                  ( gnutls-opencdk.html#cdk-subpkt-tcdk_subpkt_t  node,
                                             int type,
                                             const 
../gss/gss-ext.html#voidvoid  *buf,
                                             size_t buflen);
unsigned char* 
gnutls-opencdk.html#cdk-userid-pref-get-arraycdk_userid_pref_get_array     ( gnutls-opencdk.html#cdk-pkt-userid-tcdk_pkt_userid_t  id,
                                             int type,
                                             size_t *ret_len);
const unsigned char* 
gnutls-opencdk.html#cdk-key-desig-revoker-walkcdk_key_desig_revoker_walk                                             (
gnutls-opencdk.html#cdk-desig-revoker-tcdk_desig_revoker_t  root,
                                             
gnutls-opencdk.html#cdk-desig-revoker-tcdk_desig_revoker_t  *ctx,
                                             int *r_class,
                                             int *r_algid);
#define     
gnutls-opencdk.html#is-RSAis_RSA                           (a)
#define     
gnutls-opencdk.html#is-ELGis_ELG                           (a)
#define     
gnutls-opencdk.html#is-DSAis_DSA                           (a)
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-pk-encryptcdk_pk_encrypt                   ( gnutls-opencdk.html#cdk-pkt-pubkey-tcdk_pkt_pubkey_t  pk,
                                             
gnutls-opencdk.html#cdk-pkt-pubkey-enc-tcdk_pkt_pubkey_enc_t  pke,
                                             
gnutls-opencdk.html#cdk-sesskey-tcdk_sesskey_t  esk);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-pk-decryptcdk_pk_decrypt                   ( gnutls-opencdk.html#cdk-pkt-seckey-tcdk_pkt_seckey_t  sk,
                                             
gnutls-opencdk.html#cdk-pkt-pubkey-enc-tcdk_pkt_pubkey_enc_t  pke,
                                             
gnutls-opencdk.html#cdk-sesskey-tcdk_sesskey_t  *r_sk);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-pk-signcdk_pk_sign                      ( gnutls-opencdk.html#cdk-pkt-seckey-tcdk_pkt_seckey_t  sk,
                                             
gnutls-opencdk.html#cdk-pkt-signature-tcdk_pkt_signature_t  sig,
                                             unsigned char *md);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-pk-verifycdk_pk_verify                    ( gnutls-opencdk.html#cdk-pkt-pubkey-tcdk_pkt_pubkey_t  pk,
                                             
gnutls-opencdk.html#cdk-pkt-signature-tcdk_pkt_signature_t  sig,
                                             unsigned char *md);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-pk-get-mpicdk_pk_get_mpi                   ( gnutls-opencdk.html#cdk-pkt-pubkey-tcdk_pkt_pubkey_t  pk,
                                             int idx,
                                             unsigned char *buf,
                                             size_t *r_count,
                                             size_t *r_nbits);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-sk-get-mpicdk_sk_get_mpi                   ( gnutls-opencdk.html#cdk-pkt-seckey-tcdk_pkt_seckey_t  sk,
                                             int idx,
                                             unsigned char *buf,
                                             size_t *r_count,
                                             size_t *r_nbits);
int         
gnutls-opencdk.html#cdk-pk-get-nbitscdk_pk_get_nbits                 ( gnutls-opencdk.html#cdk-pkt-pubkey-tcdk_pkt_pubkey_t  pk);
int         
gnutls-opencdk.html#cdk-pk-get-npkeycdk_pk_get_npkey                 (int algo);
int         
gnutls-opencdk.html#cdk-pk-get-nskeycdk_pk_get_nskey                 (int algo);
int         
gnutls-opencdk.html#cdk-pk-get-nsigcdk_pk_get_nsig                  (int algo);
int         
gnutls-opencdk.html#cdk-pk-get-nenccdk_pk_get_nenc                  (int algo);
int         
gnutls-opencdk.html#cdk-pk-get-fingerprintcdk_pk_get_fingerprint           ( gnutls-opencdk.html#cdk-pkt-pubkey-tcdk_pkt_pubkey_t  pk,
                                             unsigned char *fpr);
unsigned int 
gnutls-opencdk.html#cdk-pk-fingerprint-get-keyidcdk_pk_fingerprint_get_keyid    (unsigned char *fpr,
                                             size_t fprlen,
                                             unsigned int *keyid);
unsigned int 
gnutls-opencdk.html#cdk-pk-get-keyidcdk_pk_get_keyid                ( gnutls-opencdk.html#cdk-pkt-pubkey-tcdk_pkt_pubkey_t  pk,
                                             unsigned int *keyid);
unsigned int 
gnutls-opencdk.html#cdk-sk-get-keyidcdk_sk_get_keyid                ( gnutls-opencdk.html#cdk-pkt-seckey-tcdk_pkt_seckey_t  sk,
                                             unsigned int *keyid);
unsigned int 
gnutls-opencdk.html#cdk-sig-get-keyidcdk_sig_get_keyid               ( gnutls-opencdk.html#cdk-pkt-signature-tcdk_pkt_signature_t  sig,
                                             unsigned int *keyid);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-sk-unprotectcdk_sk_unprotect                 ( gnutls-opencdk.html#cdk-pkt-seckey-tcdk_pkt_seckey_t  sk,
                                             const char *pw);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-sk-protectcdk_sk_protect                   ( gnutls-opencdk.html#cdk-pkt-seckey-tcdk_pkt_seckey_t  sk,
                                             const char *pw);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-pk-from-secret-keycdk_pk_from_secret_key           ( gnutls-opencdk.html#cdk-pkt-seckey-tcdk_pkt_seckey_t  sk,
                                             
gnutls-opencdk.html#cdk-pkt-pubkey-tcdk_pkt_pubkey_t  *ret_pk);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-sesskey-newcdk_sesskey_new                  ( gnutls-opencdk.html#cdk-sesskey-tcdk_sesskey_t  *r_sk);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-sesskey-freecdk_sesskey_free                 ( gnutls-opencdk.html#cdk-sesskey-tcdk_sesskey_t  sk);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-dek-newcdk_dek_new                      ( gnutls-opencdk.html#cdk-dek-tcdk_dek_t  *r_dek);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-dek-freecdk_dek_free                     ( gnutls-opencdk.html#cdk-dek-tcdk_dek_t  dek);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-dek-set-ciphercdk_dek_set_cipher               ( gnutls-opencdk.html#cdk-dek-tcdk_dek_t  dek,
                                             int algo);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-dek-set-keycdk_dek_set_key                  ( gnutls-opencdk.html#cdk-dek-tcdk_dek_t  dek,
                                             unsigned char *key,
                                             size_t keylen);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-dek-from-passphrasecdk_dek_from_passphrase          ( gnutls-opencdk.html#cdk-dek-tcdk_dek_t  *ret_dek,
                                             int cipher_algo,
                                             
gnutls-opencdk.html#cdk-s2k-tcdk_s2k_t  s2k,
                                             int mode,
                                             const char *pw);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-dek-encode-pkcs1cdk_dek_encode_pkcs1             ( gnutls-opencdk.html#cdk-dek-tcdk_dek_t  dek,
                                             int nbits,
                                             
gnutls-opencdk.html#cdk-sesskey-tcdk_sesskey_t  *r_esk);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-dek-decode-pkcs1cdk_dek_decode_pkcs1             ( gnutls-opencdk.html#cdk-dek-tcdk_dek_t  *ret_dek,
                                             
gnutls-opencdk.html#cdk-sesskey-tcdk_sesskey_t  esk);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-dek-extractcdk_dek_extract                  ( gnutls-opencdk.html#cdk-dek-tcdk_dek_t  *ret_dek,
                                             
gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             
gnutls-opencdk.html#cdk-pkt-pubkey-enc-tcdk_pkt_pubkey_enc_t  enc,
                                             
gnutls-opencdk.html#cdk-pkt-seckey-tcdk_pkt_seckey_t  sk);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-dek-set-mdc-flagcdk_dek_set_mdc_flag             ( gnutls-opencdk.html#cdk-dek-tcdk_dek_t  dek,
                                             int val);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-s2k-newcdk_s2k_new                      ( gnutls-opencdk.html#cdk-s2k-tcdk_s2k_t  *ret_s2k,
                                             int mode,
                                             int algo,
                                             unsigned char *salt);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-s2k-freecdk_s2k_free                     ( gnutls-opencdk.html#cdk-s2k-tcdk_s2k_t  s2k);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-file-armorcdk_file_armor                   ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             const char *file,
                                             const char *output);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-file-dearmorcdk_file_dearmor                 (const char *file,
                                             const char *output);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-armor-filter-usecdk_armor_filter_use             ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  inp);
int         
gnutls-opencdk.html#cdk-stream-controlcdk_stream_control               ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             int ctl,
                                             int val);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-stream-opencdk_stream_open                  (const char *file,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  *ret_s);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-stream-newcdk_stream_new                   (const char *file,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  *ret_s);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-stream-createcdk_stream_create                (const char *file,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  *ret_s);
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  gnutls-opencdk.html#cdk-stream-tmpcdk_stream_tmp                  (void);
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  gnutls-opencdk.html#cdk-stream-tmp-from-memcdk_stream_tmp_from_mem         (const ../gss/gss-ext.html#voidvoid  *buf,
                                             size_t count);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-stream-tmp-set-modecdk_stream_tmp_set_mode          ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             int val);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-stream-flushcdk_stream_flush                 ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-stream-set-cachecdk_stream_set_cache             ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             int val);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-stream-filter-disablecdk_stream_filter_disable        ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             int type);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-stream-closecdk_stream_close                 ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s);
unsigned    
gnutls-opencdk.html#cdk-stream-get-lengthcdk_stream_get_length            ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s);
int         
gnutls-opencdk.html#cdk-stream-readcdk_stream_read                  ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             
../gss/gss-ext.html#voidvoid  *buf,
                                             size_t count);
int         
gnutls-opencdk.html#cdk-stream-writecdk_stream_write                 ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             const 
../gss/gss-ext.html#voidvoid  *buf,
                                             size_t count);
int         
gnutls-opencdk.html#cdk-stream-putccdk_stream_putc                  ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             int c);
int         
gnutls-opencdk.html#cdk-stream-getccdk_stream_getc                  ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s);
int         
gnutls-opencdk.html#cdk-stream-eofcdk_stream_eof                   ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s);
long        
gnutls-opencdk.html#cdk-stream-tellcdk_stream_tell                  ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-stream-seekcdk_stream_seek                  ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             long offset);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-stream-set-armor-flagcdk_stream_set_armor_flag        ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             int type);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-stream-set-literal-flagcdk_stream_set_literal_flag      ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             int mode,
                                             const char *fname);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-stream-set-cipher-flagcdk_stream_set_cipher_flag       ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             
gnutls-opencdk.html#cdk-dek-tcdk_dek_t  dek,
                                             int use_mdc);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-stream-set-compress-flagcdk_stream_set_compress_flag     ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             int algo,
                                             int level);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-stream-set-hash-flagcdk_stream_set_hash_flag         ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             int algo);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-stream-set-text-flagcdk_stream_set_text_flag         ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             const char *lf);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-stream-kick-offcdk_stream_kick_off              ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  inp,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  out);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-stream-mmapcdk_stream_mmap                  ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             unsigned char **ret_buf,
                                             size_t *ret_count);
int         
gnutls-opencdk.html#cdk-stream-peekcdk_stream_peek                  ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  inp,
                                             unsigned char *s,
                                             size_t count);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-keydb-newcdk_keydb_new                    ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  *r_hd,
                                             int type,
                                             
../gss/gss-ext.html#voidvoid  *data,
                                             size_t count);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-keydb-opencdk_keydb_open                   ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  *ret_kr);
int         
gnutls-opencdk.html#cdk-keydb-check-skcdk_keydb_check_sk               ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd,
                                             unsigned int *keyid);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-keydb-search-startcdk_keydb_search_start           ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd,
                                             int type,
                                             
../gss/gss-ext.html#voidvoid  *desc);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-keydb-searchcdk_keydb_search                 ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd,
                                             
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  *ret_key);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-keydb-freecdk_keydb_free                   ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-keydb-get-bykeyidcdk_keydb_get_bykeyid            ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd,
                                             unsigned int *keyid,
                                             
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  *ret_pk);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-keydb-get-byfprcdk_keydb_get_byfpr              ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd,
                                             unsigned char *fpr,
                                             
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  *ret_pk);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-keydb-get-bypatterncdk_keydb_get_bypattern          ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd,
                                             const char *patt,
                                             
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  *ret_pk);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-keydb-get-pkcdk_keydb_get_pk                 ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  khd,
                                             unsigned int *keyid,
                                             
gnutls-opencdk.html#cdk-pkt-pubkey-tcdk_pkt_pubkey_t  *ret_pk);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-keydb-get-skcdk_keydb_get_sk                 ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  khd,
                                             unsigned int *keyid,
                                             
gnutls-opencdk.html#cdk-pkt-seckey-tcdk_pkt_seckey_t  *ret_sk);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-keydb-get-keyblockcdk_keydb_get_keyblock           ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  inp,
                                             
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  *ret_key);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-keydb-idx-rebuildcdk_keydb_idx_rebuild            ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-keydb-exportcdk_keydb_export                 ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  out,
                                             
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  remusr);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-keydb-importcdk_keydb_import                 ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd,
                                             
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  knode,
                                             int *result);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-keydb-pk-cache-sigscdk_keydb_pk_cache_sigs          ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  pk,
                                             
gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-listkey-startcdk_listkey_start                ( gnutls-opencdk.html#cdk-listkey-tcdk_listkey_t  *r_ctx,
                                             
gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  db,
                                             const char *patt,
                                             
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  fpatt);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-listkey-closecdk_listkey_close                ( gnutls-opencdk.html#cdk-listkey-tcdk_listkey_t  ctx);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-listkey-nextcdk_listkey_next                 ( gnutls-opencdk.html#cdk-listkey-tcdk_listkey_t  ctx,
                                             
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  *ret_key);
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  gnutls-opencdk.html#cdk-kbnode-newcdk_kbnode_new                  ( gnutls-opencdk.html#cdk-packet-tcdk_packet_t  pkt);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-kbnode-read-from-memcdk_kbnode_read_from_mem         ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  *ret_node,
                                             unsigned char *buf,
                                             size_t buflen);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-kbnode-write-to-memcdk_kbnode_write_to_mem          ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  node,
                                             unsigned char *buf,
                                             size_t *r_nbytes);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-kbnode-releasecdk_kbnode_release               ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  node);
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  gnutls-opencdk.html#cdk-kbnode-walkcdk_kbnode_walk                 ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  root,
                                             
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  *ctx,
                                             int all);
gnutls-opencdk.html#cdk-packet-tcdk_packet_t  gnutls-opencdk.html#cdk-kbnode-find-packetcdk_kbnode_find_packet          ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  node,
                                             int pkttype);
gnutls-opencdk.html#cdk-packet-tcdk_packet_t  gnutls-opencdk.html#cdk-kbnode-get-packetcdk_kbnode_get_packet           ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  node);
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  gnutls-opencdk.html#cdk-kbnode-findcdk_kbnode_find                 ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  node,
                                             int pkttype);
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  gnutls-opencdk.html#cdk-kbnode-find-prevcdk_kbnode_find_prev            ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  root,
                                             
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  node,
                                             int pkttype);
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  gnutls-opencdk.html#cdk-kbnode-find-nextcdk_kbnode_find_next            ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  node,
                                             int pkttype);
../gss/gss-ext.html#voidvoid *       gnutls-opencdk.html#cdk-kbnode-get-attrcdk_kbnode_get_attr              ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  node,
                                             int pkttype,
                                             int attr);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-kbnode-hashcdk_kbnode_hash                  ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  node,
                                             
gnutls-opencdk.html#cdk-md-hd-tcdk_md_hd_t  md,
                                             int is_v4,
                                             int pkttype,
                                             int flags);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-pk-check-sigscdk_pk_check_sigs                ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  knode,
                                             
gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd,
                                             int *r_status);
int         
gnutls-opencdk.html#cdk-pklist-select-algocdk_pklist_select_algo           ( gnutls-opencdk.html#cdk-keylist-tcdk_keylist_t  pkl,
                                             int preftype);
int         
gnutls-opencdk.html#cdk-pklist-use-mdccdk_pklist_use_mdc               ( gnutls-opencdk.html#cdk-keylist-tcdk_keylist_t  pkl);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-pklist-buildcdk_pklist_build                 ( gnutls-opencdk.html#cdk-keylist-tcdk_keylist_t  *ret_pkl,
                                             
gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd,
                                             
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  remusr,
                                             int use);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-pklist-releasecdk_pklist_release               ( gnutls-opencdk.html#cdk-keylist-tcdk_keylist_t  pkl);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-pklist-encryptcdk_pklist_encrypt               ( gnutls-opencdk.html#cdk-keylist-tcdk_keylist_t  pkl,
                                             
gnutls-opencdk.html#cdk-dek-tcdk_dek_t  dek,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  out);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-sklist-buildcdk_sklist_build                 ( gnutls-opencdk.html#cdk-keylist-tcdk_keylist_t  *ret_skl,
                                             
gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  db,
                                             
gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  locusr,
                                             int unlock,
                                             unsigned int use);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-sklist-releasecdk_sklist_release               ( gnutls-opencdk.html#cdk-keylist-tcdk_keylist_t  skl);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-sklist-writecdk_sklist_write                 ( gnutls-opencdk.html#cdk-keylist-tcdk_keylist_t  skl,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  outp,
                                             
gnutls-opencdk.html#cdk-md-hd-tcdk_md_hd_t  mdctx,
                                             int sigclass,
                                             int sigver);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-sklist-write-onepasscdk_sklist_write_onepass         ( gnutls-opencdk.html#cdk-keylist-tcdk_keylist_t  skl,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  outp,
                                             int sigclass,
                                             int mdalgo);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-stream-encryptcdk_stream_encrypt               ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  remusr,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  inp,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  out);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-file-encryptcdk_file_encrypt                 ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  remusr,
                                             const char *file,
                                             const char *output);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-file-decryptcdk_file_decrypt                 ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             const char *file,
                                             const char *output);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-data-transformcdk_data_transform               ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-stream-signcdk_stream_sign                  ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  inp,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  out,
                                             
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  locusr,
                                             
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  remusr,
                                             int encryptflag,
                                             int sigmode);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-file-signcdk_file_sign                    ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  locusr,
                                             
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  remusr,
                                             const char *file,
                                             const char *output,
                                             int sigmode,
                                             int encryptflag);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-stream-verifycdk_stream_verify                ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  inp,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  out);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-file-verifycdk_file_verify                  ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             const char *file,
                                             const char *output);
unsigned long 
gnutls-opencdk.html#cdk-sig-get-ulong-attrcdk_sig_get_ulong_attr         ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             int idx,
                                             int what);
const 
../gss/gss-ext.html#voidvoid * gnutls-opencdk.html#cdk-sig-get-data-attrcdk_sig_get_data_attr            ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             int idx,
                                             int what);
int         
gnutls-opencdk.html#cdk-trustdb-get-validitycdk_trustdb_get_validity         ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  inp,
                                             
gnutls-opencdk.html#cdk-pkt-userid-tcdk_pkt_userid_t  id,
                                             int *r_val);
int         
gnutls-opencdk.html#cdk-trustdb-get-ownertrustcdk_trustdb_get_ownertrust       ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  inp,
                                             
gnutls-opencdk.html#cdk-pkt-pubkey-tcdk_pkt_pubkey_t  pk,
                                             int *r_val,
                                             int *r_flags);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-strlist-freecdk_strlist_free                 ( gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  sl);
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  gnutls-opencdk.html#cdk-strlist-addcdk_strlist_add                ( gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  *list,
                                             const char *string);
const char* 
gnutls-opencdk.html#cdk-strlist-walkcdk_strlist_walk                 ( gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  root,
                                             
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  *context);
const char* 
gnutls-opencdk.html#cdk-check-versioncdk_check_version                (const char *req_version);
char*       
gnutls-opencdk.html#cdk-utf8-encodecdk_utf8_encode                  (const char *string);
char*       
gnutls-opencdk.html#cdk-utf8-decodecdk_utf8_decode                  (const char *string,
                                             size_t length,
                                             int delim);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-keyserver-recv-keycdk_keyserver_recv_key           (const char *host,
                                             int port,
                                             unsigned char *keyid,
                                             int kid_type,
                                             
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  *r_key);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-keygen-newcdk_keygen_new                   ( gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t  *r_hd);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-keygen-freecdk_keygen_free                  ( gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t  hd);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-keygen-set-prefscdk_keygen_set_prefs             ( gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t  hd);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-keygen-set-algo-infocdk_keygen_set_algo_info         ( gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t  hd,
                                             int type);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-keygen-set-mdc-featurecdk_keygen_set_mdc_feature       ( gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t  hd,
                                             int val);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-keygen-set-keyserver-flagscdk_keygen_set_keyserver_flags   ( gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t  hd,
                                             int no_modify,
                                             const char *pref_url);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-keygen-set-expire-datecdk_keygen_set_expire_date       ( gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t  hd,
                                             int type,
                                             long timestamp);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-keygen-set-namecdk_keygen_set_name              ( gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t  hd,
                                             const char *name);
../gss/gss-ext.html#voidvoid         gnutls-opencdk.html#cdk-keygen-set-passphrasecdk_keygen_set_passphrase        ( gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t  hd,
                                             const char *pass);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-keygen-startcdk_keygen_start                 ( gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t  hd);
gnutls-opencdk.html#cdk-error-tcdk_error_t  gnutls-opencdk.html#cdk-keygen-savecdk_keygen_save                  ( gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t  hd,
                                             const char *pubf,
                                             const char *secf);
Description
Details
OPENCDK_VERSION
#define OPENCDK_VERSION "0.5.5"
struct cdk_ctx_s
struct cdk_ctx_s;
cdk_ctx_t
typedef struct cdk_ctx_s *cdk_ctx_t;
struct cdk_strlist_s
struct cdk_strlist_s;
cdk_strlist_t
typedef struct cdk_strlist_s *cdk_strlist_t;
struct cdk_sesskey_s
struct cdk_sesskey_s;
cdk_sesskey_t
typedef struct cdk_sesskey_s *cdk_sesskey_t;
struct cdk_listkey_s
struct cdk_listkey_s;
cdk_listkey_t
typedef struct cdk_listkey_s *cdk_listkey_t;
struct cdk_mpi_s
struct cdk_mpi_s;
cdk_mpi_t
typedef struct cdk_mpi_s *cdk_mpi_t;
struct cdk_dek_s
struct cdk_dek_s;
cdk_dek_t
typedef struct cdk_dek_s *cdk_dek_t;
struct cdk_s2k_s
struct cdk_s2k_s;
cdk_s2k_t
typedef struct cdk_s2k_s *cdk_s2k_t;
struct cdk_stream_s
struct cdk_stream_s;
cdk_stream_t
typedef struct cdk_stream_s *cdk_stream_t;
struct cdk_prefitem_s
struct cdk_prefitem_s;
cdk_prefitem_t
typedef struct cdk_prefitem_s *cdk_prefitem_t;
struct cdk_kbnode_s
struct cdk_kbnode_s;
cdk_kbnode_t
typedef struct cdk_kbnode_s *cdk_kbnode_t;
struct cdk_keydb_hd_s
struct cdk_keydb_hd_s;
cdk_keydb_hd_t
typedef struct cdk_keydb_hd_s *cdk_keydb_hd_t;
struct cdk_keylist_s
struct cdk_keylist_s;
cdk_keylist_t
typedef struct cdk_keylist_s *cdk_keylist_t;
struct cdk_subpkt_s
struct cdk_subpkt_s;
cdk_subpkt_t
typedef struct cdk_subpkt_s *cdk_subpkt_t;
struct cdk_keygen_ctx_s
struct cdk_keygen_ctx_s;
cdk_keygen_ctx_t
typedef struct cdk_keygen_ctx_s *cdk_keygen_ctx_t;
struct cdk_desig_revoker_s
struct cdk_desig_revoker_s;
cdk_desig_revoker_t
typedef struct cdk_desig_revoker_s *cdk_desig_revoker_t;
struct cdk_md_hd_s
struct cdk_md_hd_s;
cdk_md_hd_t
typedef struct cdk_md_hd_s *cdk_md_hd_t;
struct cdk_cipher_hd_s
struct cdk_cipher_hd_s;
cdk_cipher_hd_t
typedef struct cdk_cipher_hd_s *cdk_cipher_hd_t;
enum cdk_error_t
typedef enum {
    CDK_EOF = -1,
    CDK_Success = 0,
    CDK_General_Error = 1,
    CDK_File_Error = 2,
    CDK_Bad_Sig = 3,
    CDK_Inv_Packet = 4,
    CDK_Inv_Algo = 5,
    CDK_Not_Implemented = 6,
    CDK_Gcry_Error = 7,
    CDK_Armor_Error = 8,
    CDK_Armor_CRC_Error = 9,
    CDK_MPI_Error = 10,
    CDK_Inv_Value = 11,
    CDK_Error_No_Key = 12,
    CDK_Chksum_Error = 13,
    CDK_Time_Conflict = 14,
    CDK_Zlib_Error = 15,
    CDK_Weak_Key = 16,
    CDK_Out_Of_Core = 17,
    CDK_Wrong_Seckey = 18,
    CDK_Bad_MDC = 19,
    CDK_Inv_Mode = 20,
    CDK_Error_No_Keyring = 21,
    CDK_Wrong_Format = 22,
    CDK_Inv_Packet_Ver = 23,
    CDK_Too_Short = 24,
    CDK_Unusable_Key = 25,
} cdk_error_t;
enum cdk_packet_type_t
typedef enum {
    CDK_PKT_RESERVED      =  0,
    CDK_PKT_PUBKEY_ENC    =  1,
    CDK_PKT_SIGNATURE     =  2,
    CDK_PKT_SYMKEY_ENC    =  3,
    CDK_PKT_ONEPASS_SIG   =  4,
    CDK_PKT_SECRET_KEY    =  5,
    CDK_PKT_PUBLIC_KEY    =  6,
    CDK_PKT_SECRET_SUBKEY =  7,
    CDK_PKT_COMPRESSED    =  8,
    CDK_PKT_ENCRYPTED     =  9,
    CDK_PKT_MARKER        = 10,
    CDK_PKT_LITERAL       = 11,
    CDK_PKT_RING_TRUST    = 12,
    CDK_PKT_USER_ID       = 13,
    CDK_PKT_PUBLIC_SUBKEY = 14,
    CDK_PKT_OLD_COMMENT   = 16,
    CDK_PKT_ATTRIBUTE     = 17,
    CDK_PKT_ENCRYPTED_MDC = 18,
    CDK_PKT_MDC           = 19,
} cdk_packet_type_t;
struct cdk_pkt_userid_s
struct cdk_pkt_userid_s {
    unsigned int len;
    unsigned is_primary:1;
    unsigned is_revoked:1;
    unsigned mdc_feature:1;
    cdk_prefitem_t prefs;
    unsigned char * attrib_img; /* Tag 17 if not null */
    size_t attrib_len;
    size_t prefs_size;
    unsigned int created;
    char name[1];
};
cdk_pkt_userid_t
typedef struct cdk_pkt_userid_s *cdk_pkt_userid_t;
struct cdk_pkt_pubkey_s
struct cdk_pkt_pubkey_s {
    unsigned char version;
    unsigned char pubkey_algo;
    unsigned char fpr[20];
    unsigned int keyid[2];
    unsigned int main_keyid[2];
    unsigned int timestamp;
    unsigned int expiredate;
    cdk_mpi_t mpi[4];
    unsigned is_revoked:1;
    unsigned is_invalid:1;
    unsigned has_expired:1;
    int pubkey_usage;
    cdk_pkt_userid_t uid;
    cdk_prefitem_t prefs;
    size_t prefs_size;
    cdk_desig_revoker_t revkeys;
};
cdk_pkt_pubkey_t
typedef struct cdk_pkt_pubkey_s *cdk_pkt_pubkey_t;
struct cdk_pkt_seckey_s
struct cdk_pkt_seckey_s {
    cdk_pkt_pubkey_t pk;
    unsigned int expiredate;
    int version;
    int pubkey_algo;
    unsigned int keyid[2];
    unsigned int main_keyid[2];
    unsigned char s2k_usage;
    struct {
        unsigned char algo;
        unsigned char sha1chk; /* SHA1 is used instead of a 16 bit checksum */
        cdk_s2k_t s2k;
        unsigned char iv[16];
        unsigned char ivlen;
    } protect;
    unsigned short csum;
    cdk_mpi_t mpi[4];
    unsigned char * encdata;
    size_t enclen;
    unsigned char is_protected;
    unsigned is_primary:1;
    unsigned has_expired:1;
    unsigned is_revoked:1;
};
cdk_pkt_seckey_t
typedef struct cdk_pkt_seckey_s *cdk_pkt_seckey_t;
struct cdk_pkt_signature_s
struct cdk_pkt_signature_s {
    unsigned char version;
    unsigned char sig_class;
    unsigned int timestamp;
    unsigned int expiredate;
    unsigned int keyid[2];
    unsigned char pubkey_algo;
    unsigned char digest_algo;
    unsigned char digest_start[2];
    unsigned short hashed_size;
    cdk_subpkt_t hashed;
    unsigned short unhashed_size;
    cdk_subpkt_t unhashed;
    cdk_mpi_t mpi[2];
    cdk_desig_revoker_t revkeys;
    struct {
        unsigned exportable:1;
        unsigned revocable:1;
        unsigned policy_url:1;
        unsigned notation:1;
        unsigned expired:1;
        unsigned checked:1;
        unsigned valid:1;
        unsigned missing_key:1;
    } flags;  
    unsigned int key[2]; /* only valid for key signatures */
};
cdk_pkt_signature_t
typedef struct cdk_pkt_signature_s *cdk_pkt_signature_t;
struct cdk_pkt_onepass_sig_s
struct cdk_pkt_onepass_sig_s {
    unsigned char version;
    unsigned int keyid[2];
    unsigned char sig_class;
    unsigned char digest_algo;
    unsigned char pubkey_algo;
    unsigned char last;
};
cdk_pkt_onepass_sig_t
typedef struct cdk_pkt_onepass_sig_s * cdk_pkt_onepass_sig_t;
struct cdk_pkt_pubkey_enc_s
struct cdk_pkt_pubkey_enc_s {
    unsigned char version;
    unsigned int keyid[2];
    int throw_keyid;
    unsigned char pubkey_algo;
    cdk_mpi_t mpi[2];
};
cdk_pkt_pubkey_enc_t
typedef struct cdk_pkt_pubkey_enc_s * cdk_pkt_pubkey_enc_t;
struct cdk_pkt_symkey_enc_s
struct cdk_pkt_symkey_enc_s {
    unsigned char version;
    unsigned char cipher_algo;
    cdk_s2k_t s2k;
    unsigned char seskeylen;
    unsigned char seskey[32];
};
cdk_pkt_symkey_enc_t
typedef struct cdk_pkt_symkey_enc_s *cdk_pkt_symkey_enc_t;
struct cdk_pkt_encrypted_s
struct cdk_pkt_encrypted_s {
    unsigned int len;
    int extralen;
    unsigned char mdc_method;
    cdk_stream_t buf;
};
cdk_pkt_encrypted_t
typedef struct cdk_pkt_encrypted_s *cdk_pkt_encrypted_t;
struct cdk_pkt_mdc_s
struct cdk_pkt_mdc_s {
    unsigned char hash[20];
};
cdk_pkt_mdc_t
typedef struct cdk_pkt_mdc_s *cdk_pkt_mdc_t;
struct cdk_pkt_literal_s
struct cdk_pkt_literal_s {
    unsigned int len;
    cdk_stream_t buf;
    int mode;
    unsigned int timestamp;
    int namelen;
    char name[1];
};
cdk_pkt_literal_t
typedef struct cdk_pkt_literal_s *cdk_pkt_literal_t;
struct cdk_pkt_compressed_s
struct cdk_pkt_compressed_s {
    unsigned int len;
    int algorithm;
    cdk_stream_t buf;
};
cdk_pkt_compressed_t
typedef struct cdk_pkt_compressed_s *cdk_pkt_compressed_t;
struct cdk_packet_s
struct cdk_packet_s {
    size_t pktlen; /* real packet length */
    size_t pktsize; /* length with all headers */
    int old_ctb;
    cdk_packet_type_t pkttype;
    union {
        cdk_pkt_mdc_t mdc;
        cdk_pkt_userid_t user_id;
        cdk_pkt_pubkey_t public_key;
        cdk_pkt_seckey_t secret_key;
        cdk_pkt_signature_t signature;
        cdk_pkt_pubkey_enc_t pubkey_enc;
        cdk_pkt_symkey_enc_t symkey_enc;
        cdk_pkt_compressed_t compressed;
        cdk_pkt_encrypted_t encrypted;
        cdk_pkt_literal_t literal;
        cdk_pkt_onepass_sig_t onepass_sig;
    } pkt;
};
CDK_PACKET
typedef struct cdk_packet_s CDK_PACKET;
cdk_packet_t
typedef struct cdk_packet_s *cdk_packet_t;
cdk_log_fnc_t ()
../gss/gss-ext.html#voidvoid         (*cdk_log_fnc_t)                ( ../gss/gss-ext.html#voidvoid *,
                                             ...,
                                             const char*,
                                             va_list);
Param1 : ... : Param3 : Param4 : cdk_set_log_level ()
../gss/gss-ext.html#voidvoid         cdk_set_log_level               (int lvl);set the verbosity level.
lvl :  the level
cdk_set_log_handler ()
../gss/gss-ext.html#voidvoid         cdk_set_log_handler             ( gnutls-opencdk.html#cdk-log-fnc-tcdk_log_fnc_t  logfnc,
                                             
../gss/gss-ext.html#voidvoid  *opaq);set a private handler for logging.
logfnc :  the function pointer
opaq : cdk_strerror ()
const char* cdk_strerror                    (int ec);Return an error text for the given id.
ec :  the error number
Returns : cdk_set_malloc_hooks ()
../gss/gss-ext.html#voidvoid         cdk_set_malloc_hooks            ( ../gss/gss-ext.html#voidvoid * (*new_alloc_func) (size_t n),
                                             
../gss/gss-ext.html#voidvoid * (*new_alloc_secure_func) (size_t n),
                                             
../gss/gss-ext.html#voidvoid * (*new_realloc_func) (void * p, size_t n),
                                             
../gss/gss-ext.html#voidvoid * (*new_calloc_func) (size_t m, size_t n),
                                             
../gss/gss-ext.html#voidvoid  (*new_free_func) (void *));Set private memory hooks for the lib.
new_alloc_func :  malloc replacement
new_alloc_secure_func :  secure malloc replacement
new_realloc_func :  realloc replacement
new_calloc_func :  calloc replacement
new_free_func :  free replacement
cdk_malloc_hook_initialized ()
int         cdk_malloc_hook_initialized     (void);Return if the malloc hooks are already initialized.
Returns : cdk_malloc ()
../gss/gss-ext.html#voidvoid *       cdk_malloc                      (size_t size);
size : Returns : cdk_calloc ()
../gss/gss-ext.html#voidvoid *       cdk_calloc                      (size_t n,
                                             size_t m);
n : m : Returns : cdk_realloc ()
../gss/gss-ext.html#voidvoid *       cdk_realloc                     ( ../gss/gss-ext.html#voidvoid  *ptr,
                                             size_t size);
ptr : size : Returns : cdk_salloc ()
../gss/gss-ext.html#voidvoid *       cdk_salloc                      (size_t size,
                                             int clear);
size : clear : Returns : cdk_strdup ()
char*       cdk_strdup                      (const char *ptr);
ptr : Returns : cdk_free ()
../gss/gss-ext.html#voidvoid         cdk_free                        ( ../gss/gss-ext.html#voidvoid  *ptr);
ptr : cdk_handle_new ()
int         cdk_handle_new                  ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  *r_ctx);create a new session handle.
r_ctx :  context to store the handle
Returns : cdk_handle_free ()
../gss/gss-ext.html#voidvoid         cdk_handle_free                 ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  c);free the main handle.
c : cdk_handle_set_keydb ()
../gss/gss-ext.html#voidvoid         cdk_handle_set_keydb            ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             
gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  db);set the key database handle.
the function automatically detects whether this is a public or
secret keyring and the right handle is set.
hd :  session handle
db :  the database handle
cdk_handle_get_keydb ()
gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  cdk_handle_get_keydb         ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             int type);
Return the keydb handle from the session handle.
hd :  session handle
type :  type of the keyring
Returns : cdk_handle_control ()
int         cdk_handle_control              ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             int action,
                                             int cmd,
                                             ...);
Perform various control operations for the current session.
hd :  session handle
action :  flag which indicates whether put or get is requested
cmd :  command id
... : Returns : cdk_handle_set_callback ()
../gss/gss-ext.html#voidvoid         cdk_handle_set_callback         ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             
../gss/gss-ext.html#voidvoid  (*cb) (void *opa, int type, const char * s),
                                             
../gss/gss-ext.html#voidvoid  *cb_value);set the callback for filter operations.
hd :  the handle
cb :  the callback function
cb_value :  the opaque value for the function
cdk_handle_set_passphrase_cb ()
../gss/gss-ext.html#voidvoid         cdk_handle_set_passphrase_cb    ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             char* (*cb) (void *opa, const char *prompt),
                                             
../gss/gss-ext.html#voidvoid  *cb_value);set the passphrase callback.
hd :  session handle
cb :  callback function
cb_value :  the opaque value for the cb function
cdk_handle_set_armor()
#define     cdk_handle_set_armor( a, val )
a : val : cdk_handle_set_compress()
#define     cdk_handle_set_compress( a, algo, level )
a : algo : level : cdk_set_progress_handler ()
../gss/gss-ext.html#voidvoid         cdk_set_progress_handler        ( ../gss/gss-ext.html#voidvoid  (*cb) (void * hd, unsigned off,unsigned size),
                                             
../gss/gss-ext.html#voidvoid  *cb_value);
cb : cb_value : cdk_pkt_new ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_pkt_new                     ( gnutls-opencdk.html#cdk-packet-tcdk_packet_t  *r_pkt);
r_pkt : Returns : cdk_pkt_init ()
../gss/gss-ext.html#voidvoid         cdk_pkt_init                    ( gnutls-opencdk.html#cdk-packet-tcdk_packet_t  pkt);
pkt : cdk_pkt_alloc ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_pkt_alloc                   ( gnutls-opencdk.html#cdk-packet-tcdk_packet_t  *r_pkt,
                                             int pkttype);
r_pkt : pkttype : Returns : cdk_pkt_free ()
../gss/gss-ext.html#voidvoid         cdk_pkt_free                    ( gnutls-opencdk.html#cdk-packet-tcdk_packet_t  pkt);
pkt : cdk_pkt_release ()
../gss/gss-ext.html#voidvoid         cdk_pkt_release                 ( gnutls-opencdk.html#cdk-packet-tcdk_packet_t  pkt);
pkt : cdk_pkt_read ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_pkt_read                    ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  inp,
                                             
gnutls-opencdk.html#cdk-packet-tcdk_packet_t  pkt);Parse the next packet on the 
inp stream and return its contents in pkt.
inp :  the input stream
pkt :  allocated packet handle to store the packet
Returns : cdk_pkt_write ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_pkt_write                   ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  out,
                                             
gnutls-opencdk.html#cdk-packet-tcdk_packet_t  pkt);Write the contents of 
pkt into the out stream.
out :  the output stream handle
pkt :  the packet itself
Returns : cdk_subpkt_new ()
gnutls-opencdk.html#cdk-subpkt-tcdk_subpkt_t  cdk_subpkt_new                 (size_t size);Create a new sub packet node with the size of 
size.
size :  the size of the new context
Returns : cdk_subpkt_free ()
../gss/gss-ext.html#voidvoid         cdk_subpkt_free                 ( gnutls-opencdk.html#cdk-subpkt-tcdk_subpkt_t  ctx);Release the context.
ctx :  the sub packet node to free
cdk_subpkt_find ()
gnutls-opencdk.html#cdk-subpkt-tcdk_subpkt_t  cdk_subpkt_find                ( gnutls-opencdk.html#cdk-subpkt-tcdk_subpkt_t  ctx,
                                             int type);
Find the given packet type in the node. If no packet with this
type was found, return null otherwise pointer to the node.
ctx :  the sub packet node
type :  the packet type to find
Returns : cdk_subpkt_add ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_subpkt_add                  ( gnutls-opencdk.html#cdk-subpkt-tcdk_subpkt_t  root,
                                             
gnutls-opencdk.html#cdk-subpkt-tcdk_subpkt_t  node);Add the node in 
node to the root node root.
root :  the root node
node :  the node to add
Returns : cdk_subpkt_get_data ()
const unsigned char* cdk_subpkt_get_data    ( gnutls-opencdk.html#cdk-subpkt-tcdk_subpkt_t  ctx,
                                             int *r_type,
                                             size_t *r_nbytes);
Extract the data from the given sub packet. The type is returned
in 
r_type and the size in r_nbytes.
ctx :  the sub packet node
r_type :  pointer store the packet type
r_nbytes :  pointer to store the packet size
Returns : cdk_subpkt_init ()
../gss/gss-ext.html#voidvoid         cdk_subpkt_init                 ( gnutls-opencdk.html#cdk-subpkt-tcdk_subpkt_t  node,
                                             int type,
                                             const 
../gss/gss-ext.html#voidvoid  *buf,
                                             size_t buflen);
Set the packet data of the given root and set the type of it.
node :  the sub packet node
type :  type of the packet which data should be initialized
buf :  the buffer with the actual data
buflen :  the size of the data
cdk_userid_pref_get_array ()
unsigned char* cdk_userid_pref_get_array    ( gnutls-opencdk.html#cdk-pkt-userid-tcdk_pkt_userid_t  id,
                                             int type,
                                             size_t *ret_len);
id : type : ret_len : Returns : cdk_key_desig_revoker_walk ()
const unsigned char* cdk_key_desig_revoker_walk
                                            (
gnutls-opencdk.html#cdk-desig-revoker-tcdk_desig_revoker_t  root,
                                             
gnutls-opencdk.html#cdk-desig-revoker-tcdk_desig_revoker_t  *ctx,
                                             int *r_class,
                                             int *r_algid);
root : ctx : r_class : r_algid : Returns : is_RSA()
#define     is_RSA(a)
a : is_ELG()
#define is_ELG(a) ((a) == CDK_PK_ELG || (a) == CDK_PK_ELG_E)
a : is_DSA()
#define is_DSA(a) ((a) == CDK_PK_DSA)
a : cdk_pk_encrypt ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_pk_encrypt                  ( gnutls-opencdk.html#cdk-pkt-pubkey-tcdk_pkt_pubkey_t  pk,
                                             
gnutls-opencdk.html#cdk-pkt-pubkey-enc-tcdk_pkt_pubkey_enc_t  pke,
                                             
gnutls-opencdk.html#cdk-sesskey-tcdk_sesskey_t  esk);Encrypt the session key in 
esk and write its encrypted content
into the 
pke struct.
pk :  the public key
pke :  the public key encrypted packet
esk :  the actual session key
Returns : cdk_pk_decrypt ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_pk_decrypt                  ( gnutls-opencdk.html#cdk-pkt-seckey-tcdk_pkt_seckey_t  sk,
                                             
gnutls-opencdk.html#cdk-pkt-pubkey-enc-tcdk_pkt_pubkey_enc_t  pke,
                                             
gnutls-opencdk.html#cdk-sesskey-tcdk_sesskey_t  *r_sk);Decrypt the encrypted session key from 
pke into r_sk.
sk :  the secret key
pke :  public key encrypted packet
r_sk :  the object to store the plain session key
Returns : cdk_pk_sign ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_pk_sign                     ( gnutls-opencdk.html#cdk-pkt-seckey-tcdk_pkt_seckey_t  sk,
                                             
gnutls-opencdk.html#cdk-pkt-signature-tcdk_pkt_signature_t  sig,
                                             unsigned char *md);
Sign the message digest from 
md and write the result into sig.
sk :  secret key
sig :  signature
md :  the message digest
Returns : cdk_pk_verify ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_pk_verify                   ( gnutls-opencdk.html#cdk-pkt-pubkey-tcdk_pkt_pubkey_t  pk,
                                             
gnutls-opencdk.html#cdk-pkt-signature-tcdk_pkt_signature_t  sig,
                                             unsigned char *md);
Verify the signature in 
sig and compare it with the message digest in md.
pk :  the public key
sig :  signature
md :  the message digest
Returns : cdk_pk_get_mpi ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_pk_get_mpi                  ( gnutls-opencdk.html#cdk-pkt-pubkey-tcdk_pkt_pubkey_t  pk,
                                             int idx,
                                             unsigned char *buf,
                                             size_t *r_count,
                                             size_t *r_nbits);
pk : idx : buf : r_count : r_nbits : Returns : cdk_sk_get_mpi ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_sk_get_mpi                  ( gnutls-opencdk.html#cdk-pkt-seckey-tcdk_pkt_seckey_t  sk,
                                             int idx,
                                             unsigned char *buf,
                                             size_t *r_count,
                                             size_t *r_nbits);
sk : idx : buf : r_count : r_nbits : Returns : cdk_pk_get_nbits ()
int         cdk_pk_get_nbits                ( gnutls-opencdk.html#cdk-pkt-pubkey-tcdk_pkt_pubkey_t  pk);
pk : Returns : cdk_pk_get_npkey ()
int         cdk_pk_get_npkey                (int algo);
algo : Returns : cdk_pk_get_nskey ()
int         cdk_pk_get_nskey                (int algo);
algo : Returns : cdk_pk_get_nsig ()
int         cdk_pk_get_nsig                 (int algo);
algo : Returns : cdk_pk_get_nenc ()
int         cdk_pk_get_nenc                 (int algo);
algo : Returns : cdk_pk_get_fingerprint ()
int         cdk_pk_get_fingerprint          ( gnutls-opencdk.html#cdk-pkt-pubkey-tcdk_pkt_pubkey_t  pk,
                                             unsigned char *fpr);
pk : fpr : Returns : cdk_pk_fingerprint_get_keyid ()
unsigned int cdk_pk_fingerprint_get_keyid   (unsigned char *fpr,
                                             size_t fprlen,
                                             unsigned int *keyid);
fpr : fprlen : keyid : Returns : cdk_pk_get_keyid ()
unsigned int cdk_pk_get_keyid               ( gnutls-opencdk.html#cdk-pkt-pubkey-tcdk_pkt_pubkey_t  pk,
                                             unsigned int *keyid);
pk : keyid : Returns : cdk_sk_get_keyid ()
unsigned int cdk_sk_get_keyid               ( gnutls-opencdk.html#cdk-pkt-seckey-tcdk_pkt_seckey_t  sk,
                                             unsigned int *keyid);
sk : keyid : Returns : cdk_sig_get_keyid ()
unsigned int cdk_sig_get_keyid              ( gnutls-opencdk.html#cdk-pkt-signature-tcdk_pkt_signature_t  sig,
                                             unsigned int *keyid);
sig : keyid : Returns : cdk_sk_unprotect ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_sk_unprotect                ( gnutls-opencdk.html#cdk-pkt-seckey-tcdk_pkt_seckey_t  sk,
                                             const char *pw);
sk : pw : Returns : cdk_sk_protect ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_sk_protect                  ( gnutls-opencdk.html#cdk-pkt-seckey-tcdk_pkt_seckey_t  sk,
                                             const char *pw);
sk : pw : Returns : cdk_pk_from_secret_key ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_pk_from_secret_key          ( gnutls-opencdk.html#cdk-pkt-seckey-tcdk_pkt_seckey_t  sk,
                                             
gnutls-opencdk.html#cdk-pkt-pubkey-tcdk_pkt_pubkey_t  *ret_pk);Create a new public key from a secret key.
sk :  the secret key
ret_pk :  the new public key
Returns : cdk_sesskey_new ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_sesskey_new                 ( gnutls-opencdk.html#cdk-sesskey-tcdk_sesskey_t  *r_sk);
r_sk : Returns : cdk_sesskey_free ()
../gss/gss-ext.html#voidvoid         cdk_sesskey_free                ( gnutls-opencdk.html#cdk-sesskey-tcdk_sesskey_t  sk);
sk : cdk_dek_new ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_dek_new                     ( gnutls-opencdk.html#cdk-dek-tcdk_dek_t  *r_dek);
r_dek : Returns : cdk_dek_free ()
../gss/gss-ext.html#voidvoid         cdk_dek_free                    ( gnutls-opencdk.html#cdk-dek-tcdk_dek_t  dek);
dek : cdk_dek_set_cipher ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_dek_set_cipher              ( gnutls-opencdk.html#cdk-dek-tcdk_dek_t  dek,
                                             int algo);
dek : algo : Returns : cdk_dek_set_key ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_dek_set_key                 ( gnutls-opencdk.html#cdk-dek-tcdk_dek_t  dek,
                                             unsigned char *key,
                                             size_t keylen);
dek : key : keylen : Returns : cdk_dek_from_passphrase ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_dek_from_passphrase         ( gnutls-opencdk.html#cdk-dek-tcdk_dek_t  *ret_dek,
                                             int cipher_algo,
                                             
gnutls-opencdk.html#cdk-s2k-tcdk_s2k_t  s2k,
                                             int mode,
                                             const char *pw);
ret_dek : cipher_algo : s2k : mode : pw : Returns : cdk_dek_encode_pkcs1 ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_dek_encode_pkcs1            ( gnutls-opencdk.html#cdk-dek-tcdk_dek_t  dek,
                                             int nbits,
                                             
gnutls-opencdk.html#cdk-sesskey-tcdk_sesskey_t  *r_esk);
dek : nbits : r_esk : Returns : cdk_dek_decode_pkcs1 ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_dek_decode_pkcs1            ( gnutls-opencdk.html#cdk-dek-tcdk_dek_t  *ret_dek,
                                             
gnutls-opencdk.html#cdk-sesskey-tcdk_sesskey_t  esk);
ret_dek : esk : Returns : cdk_dek_extract ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_dek_extract                 ( gnutls-opencdk.html#cdk-dek-tcdk_dek_t  *ret_dek,
                                             
gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             
gnutls-opencdk.html#cdk-pkt-pubkey-enc-tcdk_pkt_pubkey_enc_t  enc,
                                             
gnutls-opencdk.html#cdk-pkt-seckey-tcdk_pkt_seckey_t  sk);
ret_dek : hd : enc : sk : Returns : cdk_dek_set_mdc_flag ()
../gss/gss-ext.html#voidvoid         cdk_dek_set_mdc_flag            ( gnutls-opencdk.html#cdk-dek-tcdk_dek_t  dek,
                                             int val);
dek : val : cdk_s2k_new ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_s2k_new                     ( gnutls-opencdk.html#cdk-s2k-tcdk_s2k_t  *ret_s2k,
                                             int mode,
                                             int algo,
                                             unsigned char *salt);
ret_s2k : mode : algo : salt : Returns : cdk_s2k_free ()
../gss/gss-ext.html#voidvoid         cdk_s2k_free                    ( gnutls-opencdk.html#cdk-s2k-tcdk_s2k_t  s2k);
s2k : cdk_file_armor ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_file_armor                  ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             const char *file,
                                             const char *output);
Protect a file with ASCII armor.
hd :  Handle
file :  Name of the file to protect.
output :  Output filename.
Returns : cdk_file_dearmor ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_file_dearmor                (const char *file,
                                             const char *output);
Remove ASCII armor from a file.
file :  Name of the file to unprotect.
output :  Output filename.
Returns : cdk_armor_filter_use ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_armor_filter_use            ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  inp);Check if the stream contains armored data.
inp :  the stream to check
Returns : cdk_stream_control ()
int         cdk_stream_control              ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             int ctl,
                                             int val);
s : ctl : val : Returns : cdk_stream_open ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_stream_open                 (const char *file,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  *ret_s);
file :  The file to open
ret_s :  The new STREAM object
Returns : cdk_stream_new ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_stream_new                  (const char *file,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  *ret_s);
file :  The name of the new file
ret_s :  The new STREAM object
Returns : cdk_stream_create ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_stream_create               (const char *file,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  *ret_s);The difference to cdk_stream_new is, that no filtering can be used with
this kind of stream and everything is written directly to the stream.
file :  the filename
ret_s :  the object
Returns : cdk_stream_tmp ()
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  cdk_stream_tmp                 (void);
Returns : cdk_stream_tmp_from_mem ()
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  cdk_stream_tmp_from_mem        (const ../gss/gss-ext.html#voidvoid  *buf,
                                             size_t count);
buf : count : Returns : cdk_stream_tmp_set_mode ()
../gss/gss-ext.html#voidvoid         cdk_stream_tmp_set_mode         ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             int val);
s : val : cdk_stream_flush ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_stream_flush                ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s);
s : Returns : cdk_stream_set_cache ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_stream_set_cache            ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             int val);
s : val : Returns : cdk_stream_filter_disable ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_stream_filter_disable       ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             int type);
s :  The STREAM object
type :  The numberic filter ID.
Returns : cdk_stream_close ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_stream_close                ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s);This function work different for read or write streams. When the
stream is for reading, the filtering is already done and we can
simply close the file and all buffers.
But for the case it's a write stream, we need to apply all registered
filters now. The file is closed in the filter function and not here.
s :  The STREAM object.
Returns : cdk_stream_get_length ()
unsigned    cdk_stream_get_length           ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s);This file only works for read stream because it's likely that the
write stream is not flushed or even no data was inserted.
s :  The STREAM object.
Returns : cdk_stream_read ()
int         cdk_stream_read                 ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             
../gss/gss-ext.html#voidvoid  *buf,
                                             size_t count);
When this function is called the first time, it can take a while
because all filters need to be processed. Please remember that you
need to add the filters in reserved order.
s :  The STREAM object.
buf :  The buffer to insert the readed bytes.
count :  Request so much bytes.
Returns : cdk_stream_write ()
int         cdk_stream_write                ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             const 
../gss/gss-ext.html#voidvoid  *buf,
                                             size_t count);
In this function we simply write the bytes to the stream. We can't
use the filters here because it would mean they have to support
partial flushing.
s :  The STREAM object
buf :  The buffer with the values to write.
count :  The size of the buffer.
Returns : cdk_stream_putc ()
int         cdk_stream_putc                 ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             int c);
s : c : Returns : cdk_stream_getc ()
int         cdk_stream_getc                 ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s);
s : Returns : cdk_stream_eof ()
int         cdk_stream_eof                  ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s);This function will only work with read streams.
s :  The STREAM object.
Returns : cdk_stream_tell ()
long        cdk_stream_tell                 ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s);
s : Returns : cdk_stream_seek ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_stream_seek                 ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             long offset);
s : Param2 : Returns : cdk_stream_set_armor_flag ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_stream_set_armor_flag       ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             int type);
s : type : Returns : cdk_stream_set_literal_flag ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_stream_set_literal_flag     ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             int mode,
                                             const char *fname);
s : mode : fname : Returns : cdk_stream_set_cipher_flag ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_stream_set_cipher_flag      ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             
gnutls-opencdk.html#cdk-dek-tcdk_dek_t  dek,
                                             int use_mdc);
s : dek : use_mdc : Returns : cdk_stream_set_compress_flag ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_stream_set_compress_flag    ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             int algo,
                                             int level);
s : algo : level : Returns : cdk_stream_set_hash_flag ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_stream_set_hash_flag        ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             int algo);
s : algo : Returns : cdk_stream_set_text_flag ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_stream_set_text_flag        ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             const char *lf);
s : lf : Returns : cdk_stream_kick_off ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_stream_kick_off             ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  inp,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  out);
inp : out : Returns : cdk_stream_mmap ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_stream_mmap                 ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  s,
                                             unsigned char **ret_buf,
                                             size_t *ret_count);
Map the data of the given stream into a memory section. 
ret_countcontains the length of the buffer.
s :  the stream
ret_buf :  the buffer to store the content
ret_count :  length of the buffer
Returns : cdk_stream_peek ()
int         cdk_stream_peek                 ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  inp,
                                             unsigned char *s,
                                             size_t count);
The function acts like cdk_stream_read with the difference that
the file pointer is moved to the old position after the bytes were read.
inp :  the input stream handle
s :  buffer
count :  number of bytes to peek
Returns : cdk_keydb_new ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_keydb_new                   ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  *r_hd,
                                             int type,
                                             
../gss/gss-ext.html#voidvoid  *data,
                                             size_t count);
Create a new keydb object
r_hd :  handle to store the new keydb object
type :  type of the keyring
data :  data which depends on the keyring type
count :  length of the data
Returns : cdk_keydb_open ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_keydb_open                  ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  *ret_kr);Open a STREAM with the contents of the keyring from 
hd
hd :  keydb object
ret_kr :  the STREAM object which contains the data of the keyring
Returns : cdk_keydb_check_sk ()
int         cdk_keydb_check_sk              ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd,
                                             unsigned int *keyid);
hd : keyid : Returns : cdk_keydb_search_start ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_keydb_search_start          ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd,
                                             int type,
                                             
../gss/gss-ext.html#voidvoid  *desc);Create a new keydb search object.
hd : type :  specifies the search type
desc :  description which depends on the type
Returns : cdk_keydb_search ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_keydb_search                ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd,
                                             
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  *ret_key);Search for a key in the given keyring. The search mode is handled
via 
ks. If the key was found, ret_key contains the key data.
hd :  the keydb object
ret_key :  kbnode object to store the key
Returns : cdk_keydb_free ()
../gss/gss-ext.html#voidvoid         cdk_keydb_free                  ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd);Free the keydb object.
hd :  the keydb object
cdk_keydb_get_bykeyid ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_keydb_get_bykeyid           ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd,
                                             unsigned int *keyid,
                                             
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  *ret_pk);
hd : keyid : ret_pk : Returns : cdk_keydb_get_byfpr ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_keydb_get_byfpr             ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd,
                                             unsigned char *fpr,
                                             
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  *ret_pk);
hd : fpr : ret_pk : Returns : cdk_keydb_get_bypattern ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_keydb_get_bypattern         ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd,
                                             const char *patt,
                                             
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  *ret_pk);
hd : patt : ret_pk : Returns : cdk_keydb_get_pk ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_keydb_get_pk                ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  khd,
                                             unsigned int *keyid,
                                             
gnutls-opencdk.html#cdk-pkt-pubkey-tcdk_pkt_pubkey_t  *ret_pk);
khd : keyid : ret_pk : Returns : cdk_keydb_get_sk ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_keydb_get_sk                ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  khd,
                                             unsigned int *keyid,
                                             
gnutls-opencdk.html#cdk-pkt-seckey-tcdk_pkt_seckey_t  *ret_sk);
khd : keyid : ret_sk : Returns : cdk_keydb_get_keyblock ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_keydb_get_keyblock          ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  inp,
                                             
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  *ret_key);
inp : ret_key : Returns : cdk_keydb_idx_rebuild ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_keydb_idx_rebuild           ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd);Rebuild the key index files for the given key database.
hd :  key database handle
Returns : cdk_keydb_export ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_keydb_export                ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  out,
                                             
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  remusr);
hd : out : remusr : Returns : cdk_keydb_import ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_keydb_import                ( gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd,
                                             
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  knode,
                                             int *result);
hd : knode : result : Returns : cdk_keydb_pk_cache_sigs ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_keydb_pk_cache_sigs         ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  pk,
                                             
gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd);
pk : hd : Returns : cdk_listkey_start ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_listkey_start               ( gnutls-opencdk.html#cdk-listkey-tcdk_listkey_t  *r_ctx,
                                             
gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  db,
                                             const char *patt,
                                             
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  fpatt);Prepare a key listing with the given parameters. Two modes are supported.
The first mode uses string pattern to determine if the key should be
returned or not. The other mode uses a string list to request the key
which should be listed.
r_ctx :  pointer to store the new context
db :  the key database handle
patt :  string pattern
fpatt :  recipients from a stringlist to show
Returns : cdk_listkey_close ()
../gss/gss-ext.html#voidvoid         cdk_listkey_close               ( gnutls-opencdk.html#cdk-listkey-tcdk_listkey_t  ctx);Free the list key context.
ctx :  the list key context
cdk_listkey_next ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_listkey_next                ( gnutls-opencdk.html#cdk-listkey-tcdk_listkey_t  ctx,
                                             
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  *ret_key);Retrieve the next key from the pattern of the key list context.
ctx :  list key context
ret_key : Returns : cdk_kbnode_new ()
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  cdk_kbnode_new                 ( gnutls-opencdk.html#cdk-packet-tcdk_packet_t  pkt);Allocate a new key node and add the packet.
pkt :  the packet to add
Returns : cdk_kbnode_read_from_mem ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_kbnode_read_from_mem        ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  *ret_node,
                                             unsigned char *buf,
                                             size_t buflen);
Try to read a key node from the memory buffer 
buf.
ret_node :  the new key node
buf :  the buffer which stores the key sequence
buflen :  the length of the buffer
Returns : cdk_kbnode_write_to_mem ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_kbnode_write_to_mem         ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  node,
                                             unsigned char *buf,
                                             size_t *r_nbytes);
Try to write the contents of the key node to the buffer 
buf and
return the length of it in 
r_nbytes. If buf is zero, only the
length of the node is calculated and returned in 
r_nbytes.
node :  the key node
buf :  the buffer to store the node data
r_nbytes :  the new length of the buffer.
Returns : cdk_kbnode_release ()
../gss/gss-ext.html#voidvoid         cdk_kbnode_release              ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  node);Release the memory of the node.
node : cdk_kbnode_walk ()
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  cdk_kbnode_walk                ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  root,
                                             
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  *ctx,
                                             int all);
root : ctx : all : Returns : cdk_kbnode_find_packet ()
gnutls-opencdk.html#cdk-packet-tcdk_packet_t  cdk_kbnode_find_packet         ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  node,
                                             int pkttype);
Same as cdk_kbnode_find but it returns the packet instead of the node.
node :  the key node
pkttype :  packet type
Returns : cdk_kbnode_get_packet ()
gnutls-opencdk.html#cdk-packet-tcdk_packet_t  cdk_kbnode_get_packet          ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  node);Return the packet which is stored inside the node in 
node.
node :  the key node
Returns : cdk_kbnode_find ()
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  cdk_kbnode_find                ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  node,
                                             int pkttype);
Try to find the next node with the packettype 
pkttype.
node :  the key node
pkttype :  packet type
Returns : cdk_kbnode_find_prev ()
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  cdk_kbnode_find_prev           ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  root,
                                             
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  node,
                                             int pkttype);
Find the previous node (if 
pkttype = 0) or the previous node
with pkttype 
pkttype in the list starting with root of node.
root :  the root key node
node :  the key node
pkttype :  packet type
Returns : cdk_kbnode_find_next ()
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  cdk_kbnode_find_next           ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  node,
                                             int pkttype);
Ditto, but find the next packet.  The behaviour is trivial if
pkttype is 0 but if it is specified, the next node with a packet
of this type is returned.  The function has some knowledge about
the valid ordering of packets: e.g. if the next signature packet
is requested, the function will not return one if it encounters
a user-id.
node :  the key node
pkttype :  packet type
Returns : cdk_kbnode_get_attr ()
../gss/gss-ext.html#voidvoid *       cdk_kbnode_get_attr             ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  node,
                                             int pkttype,
                                             int attr);
Extract a single attribute from the specified packet type. If no
packet type is given, it is assumed that the public key is meant.
If the attr was found, it is returned as a pointer which can be cast
to a proper type.
node :  the key node
pkttype :  the packet type which the attribute should be retrieved from
attr :  the attribute to retrive
Returns : cdk_kbnode_hash ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_kbnode_hash                 ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  node,
                                             
gnutls-opencdk.html#cdk-md-hd-tcdk_md_hd_t  md,
                                             int is_v4,
                                             int pkttype,
                                             int flags);
Hash the key node contents. Two modes are supported. If the packet
type is used (!= 0) then the function searches the first node with
this type. Otherwise the node is seen as a single node and the type
is extracted from it.
node :  the key node
md : is_v4 :  OpenPGP signature (yes=1, no=0)
pkttype :  packet type to hash (if zero use the packet type from the node)
flags :  flags which depend on the operation
Returns : cdk_pk_check_sigs ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_pk_check_sigs               ( gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  knode,
                                             
gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd,
                                             int *r_status);
Check all signatures. When no key is available for checking, the
sigstat is marked as 'NOKEY'. The 
r_status contains the key flags
which are or-ed or zero when there are no flags.
knode :  the key node
hd :  the session handle
r_status :  variable to store the status of the key
Returns : cdk_pklist_select_algo ()
int         cdk_pklist_select_algo          ( gnutls-opencdk.html#cdk-keylist-tcdk_keylist_t  pkl,
                                             int preftype);
Select a symmetric cipher algorithm from a list of public keys.
This algorithm is present in all key preferences.
pkl :  the keylist
preftype :  preference type
Returns : cdk_pklist_use_mdc ()
int         cdk_pklist_use_mdc              ( gnutls-opencdk.html#cdk-keylist-tcdk_keylist_t  pkl);
pkl : Returns : cdk_pklist_build ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_pklist_build                ( gnutls-opencdk.html#cdk-keylist-tcdk_keylist_t  *ret_pkl,
                                             
gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  hd,
                                             
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  remusr,
                                             int use);
Create a public key list based on the recipient names in 
remusr.
ret_pkl :  the new keylist
hd :  the session handle
remusr :  the string list of the recipients
use :  public key usage
Returns : cdk_pklist_release ()
../gss/gss-ext.html#voidvoid         cdk_pklist_release              ( gnutls-opencdk.html#cdk-keylist-tcdk_keylist_t  pkl);Free the memory of the key list.
pkl :  the keylist
cdk_pklist_encrypt ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_pklist_encrypt              ( gnutls-opencdk.html#cdk-keylist-tcdk_keylist_t  pkl,
                                             
gnutls-opencdk.html#cdk-dek-tcdk_dek_t  dek,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  out);Encrypt the session key with each key of the list and wrap it
into a PUBKEY_ENC packet and write it to 
outp.
pkl :  the keylist
dek :  the data encryption key
out : Returns : cdk_sklist_build ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_sklist_build                ( gnutls-opencdk.html#cdk-keylist-tcdk_keylist_t  *ret_skl,
                                             
gnutls-opencdk.html#cdk-keydb-hd-tcdk_keydb_hd_t  db,
                                             
gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  locusr,
                                             int unlock,
                                             unsigned int use);
ret_skl : db : hd : locusr : unlock : use : Returns : cdk_sklist_release ()
../gss/gss-ext.html#voidvoid         cdk_sklist_release              ( gnutls-opencdk.html#cdk-keylist-tcdk_keylist_t  skl);Free the memory of the secret keylist.
skl :  secret keylist
cdk_sklist_write ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_sklist_write                ( gnutls-opencdk.html#cdk-keylist-tcdk_keylist_t  skl,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  outp,
                                             
gnutls-opencdk.html#cdk-md-hd-tcdk_md_hd_t  mdctx,
                                             int sigclass,
                                             int sigver);
Complete the sig based on 
hash and write all signatures to outp.
skl :  secret keylist
outp :  the stream to write in the data
mdctx : sigclass :  the class of the sig
sigver :  version of the sig
Returns : cdk_sklist_write_onepass ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_sklist_write_onepass        ( gnutls-opencdk.html#cdk-keylist-tcdk_keylist_t  skl,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  outp,
                                             int sigclass,
                                             int mdalgo);
Write a one-pass signature for each key in the list into 
outp.
skl :  secret keylist
outp :  the stream to write in the data
sigclass :  the class of the sig to create
mdalgo :  the message digest algorithm
Returns : cdk_stream_encrypt ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_stream_encrypt              ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  remusr,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  inp,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  out);If remusr is NULL, then symmetric encryption is used. Via the
handle the caller can set or unset multiple options.
hd :  Handle
remusr :  List of recipients
inp :  Input stream handle
out :  Output stream handle
Returns : cdk_file_encrypt ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_file_encrypt                ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  remusr,
                                             const char *file,
                                             const char *output);
hd :  Handle
remusr :  List of recipient
file :  Input file
output :  Output file
Returns : cdk_file_decrypt ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_file_decrypt                ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             const char *file,
                                             const char *output);
When the operation was successfull, hd can contain information about
the signature (when present) and more.
hd :  Handle.
file :  Name of the file to decrypt.
output :  Output filename.
Returns : cdk_data_transform ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_data_transform              ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd);This function transforms data into the given openpgp mode. It works
exactly like the cdk_file_xxx functions with the exception that it can
be used with memory and not with streams or files.
hd :  session handle
mode :  crypto mode
locusr :  local user list (sign mode only)
remusr :  remote users 'recipients'
inbuf :  input buffer with data
insize :  length of data in bytes
outbuf :  pointer to the output data (will be allocated)
outsize :  size of the new data in bytes
modval :  value for the modus (for example sign mode)
Returns : cdk_stream_sign ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_stream_sign                 ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  inp,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  out,
                                             
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  locusr,
                                             
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  remusr,
                                             int encryptflag,
                                             int sigmode);
Sign the data from the STREAM 
inp.
hd :  session handle
inp :  input stream
out :  output stream
locusr :  local user list for signing
remusr : encryptflag :  shall the output be encrypted? (1/0)
sigmode :  signature mode
Returns : cdk_file_sign ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_file_sign                   ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  locusr,
                                             
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  remusr,
                                             const char *file,
                                             const char *output,
                                             int sigmode,
                                             int encryptflag);
Sign a file.
hd : locusr :  List of userid which should be used for signing
remusr :  If encrypt is valid, the list of recipients
file :  Name of the input file
output :  Name of the output file
sigmode :  Signature mode
encryptflag : Returns : cdk_stream_verify ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_stream_verify               ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  inp,
                                             
gnutls-opencdk.html#cdk-stream-tcdk_stream_t  out);
hd : inp : out : Returns : cdk_file_verify ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_file_verify                 ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             const char *file,
                                             const char *output);
Verify a signature.
hd :  the session handle
file :  the input file
output :  the output file
Returns : cdk_sig_get_ulong_attr ()
unsigned long cdk_sig_get_ulong_attr        ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             int idx,
                                             int what);
Extract the requested attribute of the signature. The returned value
is always an integer (max. 32-bit).
hd :  session handle
idx :  index of the signature
what :  attribute id
Returns : cdk_sig_get_data_attr ()
const ../gss/gss-ext.html#voidvoid * cdk_sig_get_data_attr           ( gnutls-opencdk.html#cdk-ctx-tcdk_ctx_t  hd,
                                             int idx,
                                             int what);
Extract the requested attribute of the signature. The returned value
is always a constant object to the data.
hd :  session handle
idx :  index of the signature
what :  attribute id.
Returns : cdk_trustdb_get_validity ()
int         cdk_trustdb_get_validity        ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  inp,
                                             
gnutls-opencdk.html#cdk-pkt-userid-tcdk_pkt_userid_t  id,
                                             int *r_val);
inp : id : r_val : Returns : cdk_trustdb_get_ownertrust ()
int         cdk_trustdb_get_ownertrust      ( gnutls-opencdk.html#cdk-stream-tcdk_stream_t  inp,
                                             
gnutls-opencdk.html#cdk-pkt-pubkey-tcdk_pkt_pubkey_t  pk,
                                             int *r_val,
                                             int *r_flags);
inp : pk : r_val : r_flags : Returns : cdk_strlist_free ()
../gss/gss-ext.html#voidvoid         cdk_strlist_free                ( gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  sl);
sl : cdk_strlist_add ()
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  cdk_strlist_add               ( gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  *list,
                                             const char *string);
list : string : Returns : cdk_strlist_walk ()
const char* cdk_strlist_walk                ( gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  root,
                                             
gnutls-opencdk.html#cdk-strlist-tcdk_strlist_t  *context);
root : context : Returns : cdk_check_version ()
const char* cdk_check_version               (const char *req_version);Check that the the version of the library is at minimum the requested
one and return the version string; return NULL if the condition is
not satisfied.  If a NULL is passed to this function, no check is done,
but the version string is simply returned.
req_version :  The requested version
Returns : cdk_utf8_encode ()
char*       cdk_utf8_encode                 (const char *string);
string : Returns : cdk_utf8_decode ()
char*       cdk_utf8_decode                 (const char *string,
                                             size_t length,
                                             int delim);
string : length : delim : Returns : cdk_keyserver_recv_key ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_keyserver_recv_key          (const char *host,
                                             int port,
                                             unsigned char *keyid,
                                             int kid_type,
                                             
gnutls-opencdk.html#cdk-kbnode-tcdk_kbnode_t  *r_key);Receive a key from a keyserver.
host :  URL or hostname of the keyserver
port :  The port to use for the connection
keyid :  KeyID of the key to retrieve
kid_type :  KeyID type (long, short, fingerprint)
r_key : Returns : cdk_keygen_new ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_keygen_new                  ( gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t  *r_hd);
r_hd :  the new object
Returns : cdk_keygen_free ()
../gss/gss-ext.html#voidvoid         cdk_keygen_free                 ( gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t  hd);
hd :  the keygen object
cdk_keygen_set_prefs ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_keygen_set_prefs            ( gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t  hd);
hd :  the keygen object
type : array :  one-octet array with algorithm numers
n : Returns : cdk_keygen_set_algo_info ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_keygen_set_algo_info        ( gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t  hd,
                                             int type);
hd :  the keygen object.
type :  key type (primary=0, subkey=1)
algo :  algorithm compliant with rfc2440
bits :  lengt of the key in bits
Returns : cdk_keygen_set_mdc_feature ()
../gss/gss-ext.html#voidvoid         cdk_keygen_set_mdc_feature      ( gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t  hd,
                                             int val);
if you want a RFC2440 compliant key, you've to disable this feature
until the rfc2440-bis8 becomes the next standard.
hd :  keygen object
val :  boolean( yes=1, no=0)
cdk_keygen_set_keyserver_flags ()
../gss/gss-ext.html#voidvoid         cdk_keygen_set_keyserver_flags  ( gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t  hd,
                                             int no_modify,
                                             const char *pref_url);
hd : no_modify : pref_url : cdk_keygen_set_expire_date ()
../gss/gss-ext.html#voidvoid         cdk_keygen_set_expire_date      ( gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t  hd,
                                             int type,
                                             long timestamp);
hd :  keygen object
type :  key type( 0=primary, 1=seconardy)
Param3 : cdk_keygen_set_name ()
../gss/gss-ext.html#voidvoid         cdk_keygen_set_name             ( gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t  hd,
                                             const char *name);
The name will be encoded in UTF8 to avoid problems.
hd :  the keygen object
name :  name
cdk_keygen_set_passphrase ()
../gss/gss-ext.html#voidvoid         cdk_keygen_set_passphrase       ( gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t  hd,
                                             const char *pass);
hd : pass : cdk_keygen_start ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_keygen_start                ( gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t  hd);
hd :  the keygen object
Returns : cdk_keygen_save ()
gnutls-opencdk.html#cdk-error-tcdk_error_t  cdk_keygen_save                 ( gnutls-opencdk.html#cdk-keygen-ctx-tcdk_keygen_ctx_t  hd,
                                             const char *pubf,
                                             const char *secf);
hd :  the keygen object
pubf : secf : Returns : 