lib/opencdk/opencdk.h

   1 /* opencdk.h - Open Crypto Development Kit (OpenCDK)
   2  * Copyright (C) 2001, 2002, 2003, 2006, 2007, 2008, 2010 Free Software
   3  * Foundation, Inc.
   4  *
   5  * Author: Timo Schulz
   6  *
   7  * This file is part of OpenCDK.
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public License
  11  * as published by the Free Software Foundation; either version 2.1 of
  12  * the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  22  * 02110-1301 USA
  23  *
  24  */
  25
  26 #ifndef OPENCDK_H
  27 #define OPENCDK_H
  28
  29 #include <stddef.h>             /* for size_t */
  30 #include <stdarg.h>
  31 #include <gnutls_int.h>
  32 #include <gnutls_mem.h>
  33 #include <gnutls/gnutls.h>
  34 #include <gnutls_errors.h>
  35 #include <gnutls_hash_int.h>
  36
  37 /* The OpenCDK version as a string. */
  38 #define OPENCDK_VERSION "0.6.6"
  39
  40 /* The OpenCDK version as integer components major.minor.path */
  41 #define OPENCDK_VERSION_MAJOR 0
  42 #define OPENCDK_VERSION_MINOR 6
  43 #define OPENCDK_VERSION_PATCH 6
  44
  45 #ifdef __cplusplus
  46 extern "C"
  47 {
  48 #endif
  49
  50 /* General contexts */
  51
  52 /* 'Session' handle to support the various options and run-time
  53    information. */
  54   struct cdk_ctx_s;
  55   typedef struct cdk_ctx_s *cdk_ctx_t;
  56
  57 /* A generic context to store list of strings. */
  58   struct cdk_strlist_s;
  59   typedef struct cdk_strlist_s *cdk_strlist_t;
  60
  61 /* Context used to list keys of a keyring. */
  62   struct cdk_listkey_s;
  63   typedef struct cdk_listkey_s *cdk_listkey_t;
  64
  65 /* Opaque String to Key (S2K) handle. */
  66   struct cdk_s2k_s;
  67   typedef struct cdk_s2k_s *cdk_s2k_t;
  68
  69 /* Abstract I/O object, a stream, which is used for most operations. */
  70   struct cdk_stream_s;
  71   typedef struct cdk_stream_s *cdk_stream_t;
  72
  73 /* Opaque handle for the user ID preferences. */
  74   struct cdk_prefitem_s;
  75   typedef struct cdk_prefitem_s *cdk_prefitem_t;
  76
  77 /* Node to store a single key node packet. */
  78   struct cdk_kbnode_s;
  79   typedef struct cdk_kbnode_s *cdk_kbnode_t;
  80
  81 /* Key database handle. */
  82   struct cdk_keydb_hd_s;
  83   typedef struct cdk_keydb_hd_s *cdk_keydb_hd_t;
  84
  85   struct cdk_keydb_search_s;
  86   typedef struct cdk_keydb_search_s *cdk_keydb_search_t;
  87
  88 /* Context to store a list of recipient keys. */
  89   struct cdk_keylist_s;
  90   typedef struct cdk_keylist_s *cdk_keylist_t;
  91
  92 /* Context to encapsulate a single sub packet of a signature. */
  93   struct cdk_subpkt_s;
  94   typedef struct cdk_subpkt_s *cdk_subpkt_t;
  95
  96 /* Context used to generate key pairs. */
  97   struct cdk_keygen_ctx_s;
  98   typedef struct cdk_keygen_ctx_s *cdk_keygen_ctx_t;
  99
 100 /* Handle for a single designated revoker. */
 101   struct cdk_desig_revoker_s;
 102   typedef struct cdk_desig_revoker_s *cdk_desig_revoker_t;
 103
 104 /* Alias for backward compatibility. */
 105   typedef bigint_t cdk_mpi_t;
 106
 107
 108 /* All valid error constants. */
 109   typedef enum
 110   {
 111     CDK_EOF = -1,
 112     CDK_Success = 0,
 113     CDK_General_Error = 1,
 114     CDK_File_Error = 2,
 115     CDK_Bad_Sig = 3,
 116     CDK_Inv_Packet = 4,
 117     CDK_Inv_Algo = 5,
 118     CDK_Not_Implemented = 6,
 119     CDK_Armor_Error = 8,
 120     CDK_Armor_CRC_Error = 9,
 121     CDK_MPI_Error = 10,
 122     CDK_Inv_Value = 11,
 123     CDK_Error_No_Key = 12,
 124     CDK_Chksum_Error = 13,
 125     CDK_Time_Conflict = 14,
 126     CDK_Zlib_Error = 15,
 127     CDK_Weak_Key = 16,
 128     CDK_Out_Of_Core = 17,
 129     CDK_Wrong_Seckey = 18,
 130     CDK_Bad_MDC = 19,
 131     CDK_Inv_Mode = 20,
 132     CDK_Error_No_Keyring = 21,
 133     CDK_Wrong_Format = 22,
 134     CDK_Inv_Packet_Ver = 23,
 135     CDK_Too_Short = 24,
 136     CDK_Unusable_Key = 25,
 137     CDK_No_Data = 26,
 138     CDK_No_Passphrase = 27,
 139     CDK_Network_Error = 28
 140   } cdk_error_t;
 141
 142
 143   enum cdk_control_flags
 144   {
 145     CDK_CTLF_SET = 0,           /* Value to set an option */
 146     CDK_CTLF_GET = 1,           /* Value to get an option */
 147     CDK_CTL_DIGEST = 10,        /* Option to set the digest algorithm. */
 148     CDK_CTL_ARMOR = 12,         /* Option to enable armor output. */
 149     CDK_CTL_COMPRESS = 13,      /* Option to enable compression. */
 150     CDK_CTL_COMPAT = 14,        /* Option to switch in compat mode. */
 151     CDK_CTL_OVERWRITE = 15,     /* Option to enable file overwritting. */
 152     CDK_CTL_S2K = 16,           /* Option to set S2K values. */
 153     CDK_CTL_FORCE_DIGEST = 19,  /* Force the use of a digest algorithm. */
 154     CDK_CTL_BLOCKMODE_ON = 20   /* Enable partial body lengths */
 155   };
 156
 157
 158 /* Specifies all valid log levels. */
 159   enum cdk_log_level_t
 160   {
 161     CDK_LOG_NONE = 0,           /* No log message will be shown. */
 162     CDK_LOG_INFO = 1,
 163     CDK_LOG_DEBUG = 2,
 164     CDK_LOG_DEBUG_PKT = 3
 165   };
 166
 167
 168 /* All valid compression algorithms in OpenPGP */
 169   enum cdk_compress_algo_t
 170   {
 171     CDK_COMPRESS_NONE = 0,
 172     CDK_COMPRESS_ZIP = 1,
 173     CDK_COMPRESS_ZLIB = 2,
 174     CDK_COMPRESS_BZIP2 = 3      /* Not supported in this version */
 175   };
 176
 177 /* All valid public key algorithms valid in OpenPGP */
 178   enum cdk_pubkey_algo_t
 179   {
 180     CDK_PK_UNKNOWN = 0,
 181     CDK_PK_RSA = 1,
 182     CDK_PK_RSA_E = 2,           /* RSA-E and RSA-S are deprecated use RSA instead */
 183     CDK_PK_RSA_S = 3,           /* and use the key flags in the self signatures. */
 184     CDK_PK_ELG_E = 16,
 185     CDK_PK_DSA = 17
 186   };
 187
 188 /* The valid 'String-To-Key' modes */
 189   enum cdk_s2k_type_t
 190   {
 191     CDK_S2K_SIMPLE = 0,
 192     CDK_S2K_SALTED = 1,
 193     CDK_S2K_ITERSALTED = 3,
 194     CDK_S2K_GNU_EXT = 101
 195       /* GNU  extensions: refer to DETAILS from GnuPG:
 196          http://cvs.gnupg.org/cgi-bin/viewcvs.cgi/trunk/doc/DETAILS?root=GnuPG
 197        */
 198   };
 199
 200 /* The different kind of user ID preferences. */
 201   enum cdk_pref_type_t
 202   {
 203     CDK_PREFTYPE_NONE = 0,
 204     CDK_PREFTYPE_SYM = 1,       /* Symmetric ciphers */
 205     CDK_PREFTYPE_HASH = 2,      /* Message digests */
 206     CDK_PREFTYPE_ZIP = 3        /* Compression algorithms */
 207   };
 208
 209
 210 /* All valid sub packet types. */
 211   enum cdk_sig_subpacket_t
 212   {
 213     CDK_SIGSUBPKT_NONE = 0,
 214     CDK_SIGSUBPKT_SIG_CREATED = 2,
 215     CDK_SIGSUBPKT_SIG_EXPIRE = 3,
 216     CDK_SIGSUBPKT_EXPORTABLE = 4,
 217     CDK_SIGSUBPKT_TRUST = 5,
 218     CDK_SIGSUBPKT_REGEXP = 6,
 219     CDK_SIGSUBPKT_REVOCABLE = 7,
 220     CDK_SIGSUBPKT_KEY_EXPIRE = 9,
 221     CDK_SIGSUBPKT_PREFS_SYM = 11,
 222     CDK_SIGSUBPKT_REV_KEY = 12,
 223     CDK_SIGSUBPKT_ISSUER = 16,
 224     CDK_SIGSUBPKT_NOTATION = 20,
 225     CDK_SIGSUBPKT_PREFS_HASH = 21,
 226     CDK_SIGSUBPKT_PREFS_ZIP = 22,
 227     CDK_SIGSUBPKT_KS_FLAGS = 23,
 228     CDK_SIGSUBPKT_PREF_KS = 24,
 229     CDK_SIGSUBPKT_PRIMARY_UID = 25,
 230     CDK_SIGSUBPKT_POLICY = 26,
 231     CDK_SIGSUBPKT_KEY_FLAGS = 27,
 232     CDK_SIGSUBPKT_SIGNERS_UID = 28,
 233     CDK_SIGSUBPKT_REVOC_REASON = 29,
 234     CDK_SIGSUBPKT_FEATURES = 30
 235   };
 236
 237
 238 /* All valid armor types. */
 239   enum cdk_armor_type_t
 240   {
 241     CDK_ARMOR_MESSAGE = 0,
 242     CDK_ARMOR_PUBKEY = 1,
 243     CDK_ARMOR_SECKEY = 2,
 244     CDK_ARMOR_SIGNATURE = 3,
 245     CDK_ARMOR_CLEARSIG = 4
 246   };
 247
 248   enum cdk_keydb_flag_t
 249   {
 250     /* Valid database search modes */
 251     CDK_DBSEARCH_EXACT = 1,     /* Exact string search */
 252     CDK_DBSEARCH_SUBSTR = 2,    /* Sub string search */
 253     CDK_DBSEARCH_SHORT_KEYID = 3,       /* 32-bit keyid search */
 254     CDK_DBSEARCH_KEYID = 4,     /* 64-bit keyid search */
 255     CDK_DBSEARCH_FPR = 5,       /* 160-bit fingerprint search */
 256     CDK_DBSEARCH_NEXT = 6,      /* Enumerate all keys */
 257     CDK_DBSEARCH_AUTO = 7,      /* Try to classify the string */
 258     /* Valid database types */
 259     CDK_DBTYPE_PK_KEYRING = 100,        /* A file with one or more public keys */
 260     CDK_DBTYPE_SK_KEYRING = 101,        /* A file with one or more secret keys */
 261     CDK_DBTYPE_DATA = 102,      /* A buffer with at least one public key */
 262     CDK_DBTYPE_STREAM = 103     /* A stream is used to read keys from */
 263   };
 264
 265
 266 /* All valid modes for cdk_data_transform() */
 267   enum cdk_crypto_mode_t
 268   {
 269     CDK_CRYPTYPE_NONE = 0,
 270     CDK_CRYPTYPE_ENCRYPT = 1,
 271     CDK_CRYPTYPE_DECRYPT = 2,
 272     CDK_CRYPTYPE_SIGN = 3,
 273     CDK_CRYPTYPE_VERIFY = 4,
 274     CDK_CRYPTYPE_EXPORT = 5,
 275     CDK_CRYPTYPE_IMPORT = 6
 276   };
 277
 278 #define CDK_KEY_USG_ENCR (CDK_KEY_USG_COMM_ENCR | CDK_KEY_USG_STORAGE_ENCR)
 279 #define CDK_KEY_USG_SIGN (CDK_KEY_USG_DATA_SIGN | CDK_KEY_USG_CERT_SIGN)
 280 /* A list of valid public key usages. */
 281   enum cdk_key_usage_t
 282   {
 283     CDK_KEY_USG_CERT_SIGN = 1,
 284     CDK_KEY_USG_DATA_SIGN = 2,
 285     CDK_KEY_USG_COMM_ENCR = 4,
 286     CDK_KEY_USG_STORAGE_ENCR = 8,
 287     CDK_KEY_USG_SPLIT_KEY = 16,
 288     CDK_KEY_USG_AUTH = 32,
 289     CDK_KEY_USG_SHARED_KEY = 128
 290   };
 291
 292
 293 /* Valid flags for keys. */
 294   enum cdk_key_flag_t
 295   {
 296     CDK_KEY_VALID = 0,
 297     CDK_KEY_INVALID = 1,        /* Missing or wrong self signature */
 298     CDK_KEY_EXPIRED = 2,        /* Key is expired. */
 299     CDK_KEY_REVOKED = 4,        /* Key has been revoked. */
 300     CDK_KEY_NOSIGNER = 8
 301   };
 302
 303
 304 /* Trust values and flags for keys and user IDs */
 305   enum cdk_trust_flag_t
 306   {
 307     CDK_TRUST_UNKNOWN = 0,
 308     CDK_TRUST_EXPIRED = 1,
 309     CDK_TRUST_UNDEFINED = 2,
 310     CDK_TRUST_NEVER = 3,
 311     CDK_TRUST_MARGINAL = 4,
 312     CDK_TRUST_FULLY = 5,
 313     CDK_TRUST_ULTIMATE = 6,
 314     /* trust flags */
 315     CDK_TFLAG_REVOKED = 32,
 316     CDK_TFLAG_SUB_REVOKED = 64,
 317     CDK_TFLAG_DISABLED = 128
 318   };
 319
 320
 321 /* Signature states and the signature modes. */
 322   enum cdk_signature_stat_t
 323   {
 324     /* Signature status */
 325     CDK_SIGSTAT_NONE = 0,
 326     CDK_SIGSTAT_GOOD = 1,
 327     CDK_SIGSTAT_BAD = 2,
 328     CDK_SIGSTAT_NOKEY = 3,
 329     CDK_SIGSTAT_VALID = 4,      /* True if made with a valid key. */
 330     /* FIXME: We need indicators for revoked/expires signatures. */
 331
 332     /* Signature modes */
 333     CDK_SIGMODE_NORMAL = 100,
 334     CDK_SIGMODE_DETACHED = 101,
 335     CDK_SIGMODE_CLEAR = 102
 336   };
 337
 338
 339 /* Key flags. */
 340   typedef enum
 341   {
 342     CDK_FLAG_KEY_REVOKED = 256,
 343     CDK_FLAG_KEY_EXPIRED = 512,
 344     CDK_FLAG_SIG_EXPIRED = 1024
 345   } cdk_key_flags_t;
 346
 347
 348 /* Possible format for the literal data. */
 349   typedef enum
 350   {
 351     CDK_LITFMT_BINARY = 0,
 352     CDK_LITFMT_TEXT = 1,
 353     CDK_LITFMT_UNICODE = 2
 354   } cdk_lit_format_t;
 355
 356 /* Valid OpenPGP packet types and their IDs */
 357   typedef enum
 358   {
 359     CDK_PKT_RESERVED = 0,
 360     CDK_PKT_PUBKEY_ENC = 1,
 361     CDK_PKT_SIGNATURE = 2,
 362     CDK_PKT_ONEPASS_SIG = 4,
 363     CDK_PKT_SECRET_KEY = 5,
 364     CDK_PKT_PUBLIC_KEY = 6,
 365     CDK_PKT_SECRET_SUBKEY = 7,
 366     CDK_PKT_COMPRESSED = 8,
 367     CDK_PKT_MARKER = 10,
 368     CDK_PKT_LITERAL = 11,
 369     CDK_PKT_RING_TRUST = 12,
 370     CDK_PKT_USER_ID = 13,
 371     CDK_PKT_PUBLIC_SUBKEY = 14,
 372     CDK_PKT_OLD_COMMENT = 16,
 373     CDK_PKT_ATTRIBUTE = 17,
 374     CDK_PKT_MDC = 19
 375   } cdk_packet_type_t;
 376
 377 /* Define the maximal number of multiprecion integers for
 378    a public key. */
 379 #define MAX_CDK_PK_PARTS 4
 380
 381 /* Define the maximal number of multiprecision integers for
 382    a signature/encrypted blob issued by a secret key. */
 383 #define MAX_CDK_DATA_PARTS 2
 384
 385
 386 /* Helper macro to figure out if the packet is encrypted */
 387 #define CDK_PKT_IS_ENCRYPTED(pkttype) (\
 388      ((pkttype)==CDK_PKT_ENCRYPTED_MDC) \
 389   || ((pkttype)==CDK_PKT_ENCRYPTED))
 390
 391
 392   struct cdk_pkt_signature_s
 393   {
 394     unsigned char version;
 395     unsigned char sig_class;
 396     unsigned int timestamp;
 397     unsigned int expiredate;
 398     unsigned int keyid[2];
 399     unsigned char pubkey_algo;
 400     unsigned char digest_algo;
 401     unsigned char digest_start[2];
 402     unsigned short hashed_size;
 403     cdk_subpkt_t hashed;
 404     unsigned short unhashed_size;
 405     cdk_subpkt_t unhashed;
 406     bigint_t mpi[MAX_CDK_DATA_PARTS];
 407     cdk_desig_revoker_t revkeys;
 408     struct
 409     {
 410       unsigned exportable:1;
 411       unsigned revocable:1;
 412       unsigned policy_url:1;
 413       unsigned notation:1;
 414       unsigned expired:1;
 415       unsigned checked:1;
 416       unsigned valid:1;
 417       unsigned missing_key:1;
 418     } flags;
 419     unsigned int key[2];        /* only valid for key signatures */
 420   };
 421   typedef struct cdk_pkt_signature_s *cdk_pkt_signature_t;
 422
 423
 424   struct cdk_pkt_userid_s
 425   {
 426     unsigned int len;
 427     unsigned is_primary:1;
 428     unsigned is_revoked:1;
 429     unsigned mdc_feature:1;
 430     cdk_prefitem_t prefs;
 431     size_t prefs_size;
 432     unsigned char *attrib_img;  /* Tag 17 if not null */
 433     size_t attrib_len;
 434     cdk_pkt_signature_t selfsig;
 435     char *name;
 436   };
 437   typedef struct cdk_pkt_userid_s *cdk_pkt_userid_t;
 438
 439
 440   struct cdk_pkt_pubkey_s
 441   {
 442     unsigned char version;
 443     unsigned char pubkey_algo;
 444     unsigned char fpr[20];
 445     unsigned int keyid[2];
 446     unsigned int main_keyid[2];
 447     unsigned int timestamp;
 448     unsigned int expiredate;
 449     bigint_t mpi[MAX_CDK_PK_PARTS];
 450     unsigned is_revoked:1;
 451     unsigned is_invalid:1;
 452     unsigned has_expired:1;
 453     int pubkey_usage;
 454     cdk_pkt_userid_t uid;
 455     cdk_prefitem_t prefs;
 456     size_t prefs_size;
 457     cdk_desig_revoker_t revkeys;
 458   };
 459   typedef struct cdk_pkt_pubkey_s *cdk_pkt_pubkey_t;
 460
 461 /* Alias to define a generic public key context. */
 462   typedef cdk_pkt_pubkey_t cdk_pubkey_t;
 463
 464
 465   struct cdk_pkt_seckey_s
 466   {
 467     cdk_pkt_pubkey_t pk;
 468     unsigned int expiredate;
 469     int version;
 470     int pubkey_algo;
 471     unsigned int keyid[2];
 472     unsigned int main_keyid[2];
 473     unsigned char s2k_usage;
 474     struct
 475     {
 476       unsigned char algo;
 477       unsigned char sha1chk;    /* SHA1 is used instead of a 16 bit checksum */
 478       cdk_s2k_t s2k;
 479       unsigned char iv[16];
 480       unsigned char ivlen;
 481     } protect;
 482     unsigned short csum;
 483     bigint_t mpi[MAX_CDK_PK_PARTS];
 484     unsigned char *encdata;
 485     size_t enclen;
 486     unsigned char is_protected;
 487     unsigned is_primary:1;
 488     unsigned has_expired:1;
 489     unsigned is_revoked:1;
 490   };
 491   typedef struct cdk_pkt_seckey_s *cdk_pkt_seckey_t;
 492
 493 /* Alias to define a generic secret key context. */
 494   typedef cdk_pkt_seckey_t cdk_seckey_t;
 495
 496
 497   struct cdk_pkt_onepass_sig_s
 498   {
 499     unsigned char version;
 500     unsigned int keyid[2];
 501     unsigned char sig_class;
 502     unsigned char digest_algo;
 503     unsigned char pubkey_algo;
 504     unsigned char last;
 505   };
 506   typedef struct cdk_pkt_onepass_sig_s *cdk_pkt_onepass_sig_t;
 507
 508
 509   struct cdk_pkt_pubkey_enc_s
 510   {
 511     unsigned char version;
 512     unsigned int keyid[2];
 513     int throw_keyid;
 514     unsigned char pubkey_algo;
 515     bigint_t mpi[MAX_CDK_DATA_PARTS];
 516   };
 517   typedef struct cdk_pkt_pubkey_enc_s *cdk_pkt_pubkey_enc_t;
 518
 519   struct cdk_pkt_encrypted_s
 520   {
 521     unsigned int len;
 522     int extralen;
 523     unsigned char mdc_method;
 524     cdk_stream_t buf;
 525   };
 526   typedef struct cdk_pkt_encrypted_s *cdk_pkt_encrypted_t;
 527
 528
 529   struct cdk_pkt_mdc_s
 530   {
 531     unsigned char hash[20];
 532   };
 533   typedef struct cdk_pkt_mdc_s *cdk_pkt_mdc_t;
 534
 535
 536   struct cdk_pkt_literal_s
 537   {
 538     unsigned int len;
 539     cdk_stream_t buf;
 540     int mode;
 541     unsigned int timestamp;
 542     int namelen;
 543     char *name;
 544   };
 545   typedef struct cdk_pkt_literal_s *cdk_pkt_literal_t;
 546
 547
 548   struct cdk_pkt_compressed_s
 549   {
 550     unsigned int len;
 551     int algorithm;
 552     cdk_stream_t buf;
 553   };
 554   typedef struct cdk_pkt_compressed_s *cdk_pkt_compressed_t;
 555
 556
 557 /* Structure which represents a single OpenPGP packet. */
 558   struct cdk_packet_s
 559   {
 560     size_t pktlen;              /* real packet length */
 561     size_t pktsize;             /* length with all headers */
 562     int old_ctb;                /* 1 if RFC1991 mode is used */
 563     cdk_packet_type_t pkttype;
 564     union
 565     {
 566       cdk_pkt_mdc_t mdc;
 567       cdk_pkt_userid_t user_id;
 568       cdk_pkt_pubkey_t public_key;
 569       cdk_pkt_seckey_t secret_key;
 570       cdk_pkt_signature_t signature;
 571       cdk_pkt_pubkey_enc_t pubkey_enc;
 572       cdk_pkt_compressed_t compressed;
 573       cdk_pkt_encrypted_t encrypted;
 574       cdk_pkt_literal_t literal;
 575       cdk_pkt_onepass_sig_t onepass_sig;
 576     } pkt;
 577   };
 578   typedef struct cdk_packet_s *cdk_packet_t;
 579
 580 /* Session handle routines */
 581   cdk_error_t cdk_handle_new (cdk_ctx_t * r_ctx);
 582   void cdk_handle_free (cdk_ctx_t c);
 583
 584 /* Set the key database handle for the given session handle.
 585    The type of the key db handle (public or secret) decides
 586    which session key db handle to use. */
 587   void cdk_handle_set_keydb (cdk_ctx_t hd, cdk_keydb_hd_t db);
 588
 589 /* Convenient function to avoid to open a key db first.
 590    The user can directly use the file name, the rest is
 591    done internally. */
 592   cdk_error_t cdk_handle_set_keyring (cdk_ctx_t hd, int type,
 593                                       const char *kringname);
 594
 595 /* Return keydb handle stored in the session handle. */
 596   cdk_keydb_hd_t cdk_handle_get_keydb (cdk_ctx_t hd, int type);
 597   int cdk_handle_control (cdk_ctx_t hd, int action, int cmd, ...);
 598
 599 /* Set a passphrase callback for the given session handle. */
 600   void cdk_handle_set_passphrase_cb (cdk_ctx_t hd,
 601                                      char *(*cb) (void *opa,
 602                                                   const char *prompt),
 603                                      void *cb_value);
 604
 605 /* shortcuts for some controls */
 606
 607 /* Enable or disable armor output. */
 608 #define cdk_handle_set_armor(a, val) \
 609   cdk_handle_control ((a), CDK_CTLF_SET, CDK_CTL_ARMOR, (val))
 610
 611 /* Set the compression algorithm and level. 0 means disable compression. */
 612 #define cdk_handle_set_compress(a, algo, level) \
 613   cdk_handle_control ((a), CDK_CTLF_SET, CDK_CTL_COMPRESS, (algo), (level))
 614
 615 /* Activate partial bodies for the output. This is needed if the length
 616    of the data is not known in advance or for the use with sockets
 617    or pipes. */
 618 #define cdk_handle_set_blockmode(a, val) \
 619   cdk_handle_control ((a), CDK_CTLF_SET, CDK_CTL_BLOCKMODE_ON, (val))
 620
 621 /* Set the digest for the PK signing operation. */
 622 #define cdk_handle_set_digest(a, val) \
 623   cdk_handle_control ((a), CDK_CTLF_SET, CDK_CTL_DIGEST, (val))
 624
 625 /* Set the mode and the digest for the S2K operation. */
 626 #define cdk_handle_set_s2k(a, val1, val2) \
 627   cdk_handle_control ((a), CDK_CTLF_SET, CDK_CTL_S2K, (val1), (val2))
 628 /* Raw packet routines. */
 629
 630 /* Allocate a new packet or a new packet with the given packet type. */
 631   cdk_error_t cdk_pkt_new (cdk_packet_t * r_pkt);
 632   cdk_error_t cdk_pkt_alloc (cdk_packet_t * r_pkt, cdk_packet_type_t pkttype);
 633
 634 /* Only release the contents of the packet but not @PKT itself. */
 635   void cdk_pkt_free (cdk_packet_t pkt);
 636
 637 /* Release the packet contents and the packet structure @PKT itself. */
 638   void cdk_pkt_release (cdk_packet_t pkt);
 639
 640 /* Read or write the given output from or to the stream. */
 641   cdk_error_t cdk_pkt_read (cdk_stream_t inp, cdk_packet_t pkt);
 642   cdk_error_t cdk_pkt_write (cdk_stream_t out, cdk_packet_t pkt);
 643
 644 /* Sub packet routines */
 645   cdk_subpkt_t cdk_subpkt_new (size_t size);
 646   void cdk_subpkt_free (cdk_subpkt_t ctx);
 647   cdk_subpkt_t cdk_subpkt_find (cdk_subpkt_t ctx, size_t type);
 648   cdk_subpkt_t cdk_subpkt_find_next (cdk_subpkt_t root, size_t type);
 649   size_t cdk_subpkt_type_count (cdk_subpkt_t ctx, size_t type);
 650   cdk_subpkt_t cdk_subpkt_find_nth (cdk_subpkt_t ctx, size_t type,
 651                                     size_t index);
 652   cdk_error_t cdk_subpkt_add (cdk_subpkt_t root, cdk_subpkt_t node);
 653   const unsigned char *cdk_subpkt_get_data (cdk_subpkt_t ctx,
 654                                             size_t * r_type,
 655                                             size_t * r_nbytes);
 656   void cdk_subpkt_init (cdk_subpkt_t node, size_t type, const void *buf,
 657                         size_t buflen);
 658
 659 /* Designated Revoker routines */
 660   const unsigned char *cdk_key_desig_revoker_walk (cdk_desig_revoker_t root,
 661                                                    cdk_desig_revoker_t * ctx,
 662                                                    int *r_class,
 663                                                    int *r_algid);
 664
 665 #define is_RSA(a) ((a) == CDK_PK_RSA            \
 666                    || (a) == CDK_PK_RSA_E       \
 667                    || (a) == CDK_PK_RSA_S)
 668 #define is_ELG(a) ((a) == CDK_PK_ELG_E)
 669 #define is_DSA(a) ((a) == CDK_PK_DSA)
 670
 671 /* Encrypt the given session key @SK with the public key @PK
 672    and write the contents into the packet @PKE. */
 673   cdk_error_t cdk_pk_encrypt (cdk_pubkey_t pk, cdk_pkt_pubkey_enc_t pke,
 674                               bigint_t sk);
 675
 676 /* Decrypt the given encrypted session key in @PKE with the secret key
 677    @SK and store it in @R_SK. */
 678   cdk_error_t cdk_pk_decrypt (cdk_seckey_t sk, cdk_pkt_pubkey_enc_t pke,
 679                               bigint_t * r_sk);
 680
 681 /* Sign the given message digest @MD with the secret key @SK and
 682    store the signature in the packet @SIG. */
 683   cdk_error_t cdk_pk_sign (cdk_seckey_t sk, cdk_pkt_signature_t sig,
 684                            const unsigned char *md);
 685
 686 /* Verify the given signature in @SIG with the public key @PK
 687    and compare it against the message digest @MD. */
 688   cdk_error_t cdk_pk_verify (cdk_pubkey_t pk, cdk_pkt_signature_t sig,
 689                              const unsigned char *md);
 690
 691 /* Use cdk_pk_get_npkey() and cdk_pk_get_nskey to find out how much
 692    multiprecision integers a key consists of. */
 693
 694 /* Return a multi precision integer of the public key with the index @IDX
 695    in the buffer @BUF. @R_NWRITTEN will contain the length in octets.
 696    Optional @R_NBITS may contain the size in bits. */
 697   cdk_error_t cdk_pk_get_mpi (cdk_pubkey_t pk, size_t idx,
 698                               unsigned char *buf, size_t buflen,
 699                               size_t * r_nwritten, size_t * r_nbits);
 700
 701 /* Same as the function above but of the secret key. */
 702   cdk_error_t cdk_sk_get_mpi (cdk_seckey_t sk, size_t idx,
 703                               unsigned char *buf, size_t buflen,
 704                               size_t * r_nwritten, size_t * r_nbits);
 705
 706 /* Helper to get the exact number of multi precision integers
 707    for the given object. */
 708   int cdk_pk_get_nbits (cdk_pubkey_t pk);
 709   int cdk_pk_get_npkey (int algo);
 710   int cdk_pk_get_nskey (int algo);
 711   int cdk_pk_get_nsig (int algo);
 712   int cdk_pk_get_nenc (int algo);
 713
 714 /* Fingerprint and key ID routines. */
 715
 716 /* Calculate the fingerprint of the given public key.
 717    the FPR parameter must be at least 20 octets to hold the SHA1 hash. */
 718   cdk_error_t cdk_pk_get_fingerprint (cdk_pubkey_t pk, unsigned char *fpr);
 719
 720 /* Same as above, but with additional sanity checks of the buffer size. */
 721   cdk_error_t cdk_pk_to_fingerprint (cdk_pubkey_t pk,
 722                                      unsigned char *fpr, size_t fprlen,
 723                                      size_t * r_nout);
 724
 725 /* Derive the keyid from the fingerprint. This is only possible for
 726    modern, version 4 keys. */
 727   unsigned int cdk_pk_fingerprint_get_keyid (const unsigned char *fpr,
 728                                              size_t fprlen,
 729                                              unsigned int *keyid);
 730
 731 /* Various functions to get the keyid from the specific packet type. */
 732   unsigned int cdk_pk_get_keyid (cdk_pubkey_t pk, unsigned int *keyid);
 733   unsigned int cdk_sk_get_keyid (cdk_seckey_t sk, unsigned int *keyid);
 734   unsigned int cdk_sig_get_keyid (cdk_pkt_signature_t sig,
 735                                   unsigned int *keyid);
 736
 737 /* Key release functions. */
 738   void cdk_pk_release (cdk_pubkey_t pk);
 739   void cdk_sk_release (cdk_seckey_t sk);
 740
 741 /* Create a public key with the data from the secret key @SK. */
 742   cdk_error_t cdk_pk_from_secret_key (cdk_seckey_t sk, cdk_pubkey_t * ret_pk);
 743
 744 /* Sexp conversion of keys. */
 745   cdk_error_t cdk_pubkey_to_sexp (cdk_pubkey_t pk, char **sexp, size_t * len);
 746   cdk_error_t cdk_seckey_to_sexp (cdk_seckey_t sk, char **sexp, size_t * len);
 747
 748
 749 /* String to Key routines. */
 750   cdk_error_t cdk_s2k_new (cdk_s2k_t * ret_s2k, int mode, int digest_algo,
 751                            const unsigned char *salt);
 752   void cdk_s2k_free (cdk_s2k_t s2k);
 753
 754   cdk_error_t cdk_file_armor (cdk_ctx_t hd, const char *file,
 755                               const char *output);
 756   cdk_error_t cdk_file_dearmor (const char *file, const char *output);
 757   int cdk_armor_filter_use (cdk_stream_t inp);
 758
 759 /* Protect the inbuf with ASCII armor of the specified type.
 760    If @outbuf and @outlen are NULL, the function returns the calculated
 761    size of the base64 encoded data in @nwritten. */
 762   cdk_error_t cdk_armor_encode_buffer (const unsigned char *inbuf,
 763                                        size_t inlen, char *outbuf,
 764                                        size_t outlen, size_t * nwritten,
 765                                        int type);
 766
 767
 768 /* This context contain user callbacks for different stream operations.
 769    Some of these callbacks might be NULL to indicate that the callback
 770    is not used. */
 771   struct cdk_stream_cbs_s
 772   {
 773     cdk_error_t (*open) (void *);
 774     cdk_error_t (*release) (void *);
 775     int (*read) (void *, void *buf, size_t);
 776     int (*write) (void *, const void *buf, size_t);
 777     int (*seek) (void *, off_t);
 778   };
 779   typedef struct cdk_stream_cbs_s *cdk_stream_cbs_t;
 780
 781   int cdk_stream_is_compressed (cdk_stream_t s);
 782
 783 /* Return a stream object which is associated to a socket. */
 784   cdk_error_t cdk_stream_sockopen (const char *host, unsigned short port,
 785                                    cdk_stream_t * ret_out);
 786
 787 /* Return a stream object which is associated to an existing file. */
 788   cdk_error_t cdk_stream_open (const char *file, cdk_stream_t * ret_s);
 789
 790 /* Return a stream object which is associated to a file which will
 791    be created when the stream is closed. */
 792   cdk_error_t cdk_stream_new (const char *file, cdk_stream_t * ret_s);
 793
 794 /* Return a stream object with custom callback functions for the
 795    various core operations. */
 796   cdk_error_t cdk_stream_new_from_cbs (cdk_stream_cbs_t cbs, void *opa,
 797                                        cdk_stream_t * ret_s);
 798   cdk_error_t cdk_stream_create (const char *file, cdk_stream_t * ret_s);
 799   cdk_error_t cdk_stream_tmp_new (cdk_stream_t * r_out);
 800   cdk_error_t cdk_stream_tmp_from_mem (const void *buf, size_t buflen,
 801                                        cdk_stream_t * r_out);
 802   void cdk_stream_tmp_set_mode (cdk_stream_t s, int val);
 803   cdk_error_t cdk_stream_flush (cdk_stream_t s);
 804   cdk_error_t cdk_stream_enable_cache (cdk_stream_t s, int val);
 805   cdk_error_t cdk_stream_filter_disable (cdk_stream_t s, int type);
 806   cdk_error_t cdk_stream_close (cdk_stream_t s);
 807   off_t cdk_stream_get_length (cdk_stream_t s);
 808   int cdk_stream_read (cdk_stream_t s, void *buf, size_t count);
 809   int cdk_stream_write (cdk_stream_t s, const void *buf, size_t count);
 810   int cdk_stream_putc (cdk_stream_t s, int c);
 811   int cdk_stream_getc (cdk_stream_t s);
 812   int cdk_stream_eof (cdk_stream_t s);
 813   off_t cdk_stream_tell (cdk_stream_t s);
 814   cdk_error_t cdk_stream_seek (cdk_stream_t s, off_t offset);
 815   cdk_error_t cdk_stream_set_armor_flag (cdk_stream_t s, int type);
 816
 817 /* Push the literal filter for the given stream. */
 818   cdk_error_t cdk_stream_set_literal_flag (cdk_stream_t s,
 819                                            cdk_lit_format_t mode,
 820                                            const char *fname);
 821
 822   cdk_error_t cdk_stream_set_compress_flag (cdk_stream_t s, int algo,
 823                                             int level);
 824   cdk_error_t cdk_stream_set_hash_flag (cdk_stream_t s, int algo);
 825   cdk_error_t cdk_stream_set_text_flag (cdk_stream_t s, const char *lf);
 826   cdk_error_t cdk_stream_kick_off (cdk_stream_t inp, cdk_stream_t out);
 827   cdk_error_t cdk_stream_mmap (cdk_stream_t s, unsigned char **ret_buf,
 828                                size_t * ret_buflen);
 829   cdk_error_t cdk_stream_mmap_part (cdk_stream_t s, off_t off, size_t len,
 830                                     unsigned char **ret_buf,
 831                                     size_t * ret_buflen);
 832
 833 /* Read from the stream but restore the file pointer after reading
 834    the requested amount of bytes. */
 835   int cdk_stream_peek (cdk_stream_t inp, unsigned char *buf, size_t buflen);
 836
 837 /* A wrapper around the various new_from_XXX functions. Because
 838    the function does not support all combinations, the dedicated
 839    functions should be preferred. */
 840   cdk_error_t cdk_keydb_new (cdk_keydb_hd_t * r_hd, int type, void *data,
 841                              size_t count);
 842
 843 /* Create a new key db handle from a memory buffer. */
 844   cdk_error_t cdk_keydb_new_from_mem (cdk_keydb_hd_t * r_hd, int secret,
 845                                       const void *data, size_t datlen);
 846
 847 /* Create a new key db which uses an existing file. */
 848   cdk_error_t cdk_keydb_new_from_file (cdk_keydb_hd_t * r_hd, int secret,
 849                                        const char *fname);
 850
 851 /* Uses a stream as the key db input. For searching it is important
 852    that the seek function is supported on the stream. Furthermore,
 853    the stream is not closed in cdk_keydb_free(). The caller must do it. */
 854   cdk_error_t cdk_keydb_new_from_stream (cdk_keydb_hd_t * r_hd, int secret,
 855                                          cdk_stream_t in);
 856
 857 /* Check that a secret key with the given key ID is available. */
 858   cdk_error_t cdk_keydb_check_sk (cdk_keydb_hd_t hd, unsigned int *keyid);
 859
 860 /* Prepare the key db search. */
 861   cdk_error_t cdk_keydb_search_start (cdk_keydb_search_t * st,
 862                                       cdk_keydb_hd_t db, int type,
 863                                       void *desc);
 864
 865   void cdk_keydb_search_release (cdk_keydb_search_t st);
 866
 867 /* Return a key which matches a valid description given in
 868    cdk_keydb_search_start(). */
 869   cdk_error_t cdk_keydb_search (cdk_keydb_search_t st, cdk_keydb_hd_t hd,
 870                                 cdk_kbnode_t * ret_key);
 871
 872 /* Release the key db handle and all its resources. */
 873   void cdk_keydb_free (cdk_keydb_hd_t hd);
 874
 875 /* The following functions will try to find a key in the given key
 876    db handle either by keyid, by fingerprint or by some pattern. */
 877   cdk_error_t cdk_keydb_get_bykeyid (cdk_keydb_hd_t hd, unsigned int *keyid,
 878                                      cdk_kbnode_t * ret_pk);
 879   cdk_error_t cdk_keydb_get_byfpr (cdk_keydb_hd_t hd,
 880                                    const unsigned char *fpr,
 881                                    cdk_kbnode_t * ret_pk);
 882   cdk_error_t cdk_keydb_get_bypattern (cdk_keydb_hd_t hd, const char *patt,
 883                                        cdk_kbnode_t * ret_pk);
 884
 885 /* These function, in contrast to most other key db functions, only
 886    return the public or secret key packet without the additional
 887    signatures and user IDs. */
 888   cdk_error_t cdk_keydb_get_pk (cdk_keydb_hd_t khd, unsigned int *keyid,
 889                                 cdk_pubkey_t * ret_pk);
 890   cdk_error_t cdk_keydb_get_sk (cdk_keydb_hd_t khd, unsigned int *keyid,
 891                                 cdk_seckey_t * ret_sk);
 892
 893 /* Try to read the next key block from the given input stream.
 894    The key will be returned in @RET_KEY on success. */
 895   cdk_error_t cdk_keydb_get_keyblock (cdk_stream_t inp,
 896                                       cdk_kbnode_t * ret_key);
 897
 898 /* Rebuild the key db index if possible. */
 899   cdk_error_t cdk_keydb_idx_rebuild (cdk_keydb_hd_t db,
 900                                      cdk_keydb_search_t dbs);
 901
 902 /* Export one or more keys from the given key db handle into
 903    the stream @OUT. The export is done by substring search and
 904    uses the string list @REMUSR for the pattern. */
 905   cdk_error_t cdk_keydb_export (cdk_keydb_hd_t hd, cdk_stream_t out,
 906                                 cdk_strlist_t remusr);
 907
 908 /* Import the given key node @knode into the key db. */
 909   cdk_error_t cdk_keydb_import (cdk_keydb_hd_t hd, cdk_kbnode_t knode);
 910
 911
 912 /* List or enumerate keys from a given key db handle. */
 913
 914 /* Start the key list process. Either use @PATT for a pattern search
 915    or @FPATT for a list of pattern. */
 916   cdk_error_t cdk_listkey_start (cdk_listkey_t * r_ctx, cdk_keydb_hd_t db,
 917                                  const char *patt, cdk_strlist_t fpatt);
 918   void cdk_listkey_close (cdk_listkey_t ctx);
 919
 920 /* Return the next key which matches the pattern. */
 921   cdk_error_t cdk_listkey_next (cdk_listkey_t ctx, cdk_kbnode_t * ret_key);
 922
 923   cdk_kbnode_t cdk_kbnode_new (cdk_packet_t pkt);
 924   cdk_error_t cdk_kbnode_read_from_mem (cdk_kbnode_t * ret_node,
 925                                         const unsigned char *buf,
 926                                         size_t buflen);
 927   cdk_error_t cdk_kbnode_write_to_mem (cdk_kbnode_t node,
 928                                        unsigned char *buf, size_t * r_nbytes);
 929   cdk_error_t cdk_kbnode_write_to_mem_alloc (cdk_kbnode_t node,
 930                                              unsigned char **r_buf,
 931                                              size_t * r_buflen);
 932
 933   void cdk_kbnode_release (cdk_kbnode_t node);
 934   void cdk_kbnode_delete (cdk_kbnode_t node);
 935   void cdk_kbnode_insert (cdk_kbnode_t root, cdk_kbnode_t node,
 936                           cdk_packet_type_t pkttype);
 937   int cdk_kbnode_commit (cdk_kbnode_t * root);
 938   void cdk_kbnode_remove (cdk_kbnode_t * root, cdk_kbnode_t node);
 939   void cdk_kbnode_move (cdk_kbnode_t * root, cdk_kbnode_t node,
 940                         cdk_kbnode_t where);
 941   cdk_kbnode_t cdk_kbnode_walk (cdk_kbnode_t root, cdk_kbnode_t * ctx,
 942                                 int all);
 943   cdk_packet_t cdk_kbnode_find_packet (cdk_kbnode_t node,
 944                                        cdk_packet_type_t pkttype);
 945   cdk_packet_t cdk_kbnode_get_packet (cdk_kbnode_t node);
 946   cdk_kbnode_t cdk_kbnode_find (cdk_kbnode_t node, cdk_packet_type_t pkttype);
 947   cdk_kbnode_t cdk_kbnode_find_prev (cdk_kbnode_t root, cdk_kbnode_t node,
 948                                      cdk_packet_type_t pkttype);
 949   cdk_kbnode_t cdk_kbnode_find_next (cdk_kbnode_t node,
 950                                      cdk_packet_type_t pkttype);
 951   cdk_error_t cdk_kbnode_hash (cdk_kbnode_t node, digest_hd_st * md,
 952                                int is_v4, cdk_packet_type_t pkttype,
 953                                int flags);
 954
 955 /* Check each signature in the key node and return a summary of the
 956    key status in @r_status. Values of cdk_key_flag_t are used. */
 957   cdk_error_t cdk_pk_check_sigs (cdk_kbnode_t knode, cdk_keydb_hd_t hd,
 958                                  int *r_status);
 959
 960 /* Check the self signature of the key to make sure it is valid. */
 961   cdk_error_t cdk_pk_check_self_sig (cdk_kbnode_t knode, int *r_status);
 962
 963 /* Return a matching  algorithm from the given public key list.
 964    @PREFTYPE can be either sym-cipher/compress/digest. */
 965   int cdk_pklist_select_algo (cdk_keylist_t pkl, int preftype);
 966
 967 /* Return 0 or 1 if the given key list is able to understand the
 968    MDC feature. */
 969   int cdk_pklist_use_mdc (cdk_keylist_t pkl);
 970   cdk_error_t cdk_pklist_build (cdk_keylist_t * ret_pkl, cdk_keydb_hd_t hd,
 971                                 cdk_strlist_t remusr, int use);
 972   void cdk_pklist_release (cdk_keylist_t pkl);
 973
 974 /* Secret key lists */
 975   cdk_error_t cdk_sklist_build (cdk_keylist_t * ret_skl,
 976                                 cdk_keydb_hd_t db, cdk_ctx_t hd,
 977                                 cdk_strlist_t locusr,
 978                                 int unlock, unsigned int use);
 979   void cdk_sklist_release (cdk_keylist_t skl);
 980   cdk_error_t cdk_sklist_write (cdk_keylist_t skl, cdk_stream_t outp,
 981                                 digest_hd_st * mdctx, int sigclass,
 982                                 int sigver);
 983   cdk_error_t cdk_sklist_write_onepass (cdk_keylist_t skl, cdk_stream_t outp,
 984                                         int sigclass, int mdalgo);
 985
 986 /* Encrypt the given stream @INP with the recipients given in @REMUSR.
 987    If @REMUSR is NULL, symmetric encryption will be used. The output
 988    will be written to @OUT. */
 989   cdk_error_t cdk_stream_encrypt (cdk_ctx_t hd, cdk_strlist_t remusr,
 990                                   cdk_stream_t inp, cdk_stream_t out);
 991
 992 /* Decrypt the @INP stream into @OUT. */
 993   cdk_error_t cdk_stream_decrypt (cdk_ctx_t hd, cdk_stream_t inp,
 994                                   cdk_stream_t out);
 995
 996 /* Same as the function above but it works on files. */
 997   cdk_error_t cdk_file_encrypt (cdk_ctx_t hd, cdk_strlist_t remusr,
 998                                 const char *file, const char *output);
 999   cdk_error_t cdk_file_decrypt (cdk_ctx_t hd, const char *file,
1000                                 const char *output);
1001
1002 /* Generic function to transform data. The mode can be either sign,
1003    verify, encrypt, decrypt, import or export. The meanings of the
1004    parameters are similar to the functions above.
1005    @OUTBUF will contain the output and @OUTSIZE the length of it. */
1006   cdk_error_t cdk_data_transform (cdk_ctx_t hd, enum cdk_crypto_mode_t mode,
1007                                   cdk_strlist_t locusr, cdk_strlist_t remusr,
1008                                   const void *inbuf, size_t insize,
1009                                   unsigned char **outbuf, size_t * outsize,
1010                                   int modval);
1011
1012   int cdk_trustdb_get_validity (cdk_stream_t inp, cdk_pkt_userid_t id,
1013                                 int *r_val);
1014   int cdk_trustdb_get_ownertrust (cdk_stream_t inp, cdk_pubkey_t pk,
1015                                   int *r_val, int *r_flags);
1016
1017   void cdk_strlist_free (cdk_strlist_t sl);
1018   cdk_strlist_t cdk_strlist_add (cdk_strlist_t * list, const char *string);
1019   const char *cdk_check_version (const char *req_version);
1020 /* UTF8 */
1021   char *cdk_utf8_encode (const char *string);
1022   char *cdk_utf8_decode (const char *string, size_t length, int delim);
1023
1024 #ifdef __cplusplus
1025 }
1026 #endif
1027
1028 #endif                          /* OPENCDK_H */