lib/gnutlsxx.cpp

   1 /*
   2  * Copyright (C) 2006-2012 Free Software Foundation, Inc.
   3  *
   4  * Author: Nikos Mavrogiannopoulos
   5  *
   6  * This file is part of GnuTLS.
   7  *
   8  * The GnuTLS is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public License
  10  * as published by the Free Software Foundation; either version 2.1 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program.  If not, see <http://www.gnu.org/licenses/>
  20  *
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 # include <config.h>
  25 #endif
  26
  27 #include <gnutls/gnutlsxx.h>
  28
  29 namespace gnutls
  30 {
  31
  32   inline static int RETWRAP (int ret)
  33   {
  34     if (ret < 0)
  35       throw (exception (ret));
  36     return ret;
  37   }
  38
  39   session::session (unsigned int flags)
  40   {
  41     RETWRAP (gnutls_init (&s, flags));
  42   }
  43
  44   session::~session ()
  45   {
  46     gnutls_deinit (s);
  47   }
  48
  49   int session::bye (gnutls_close_request_t how)
  50   {
  51     return RETWRAP (gnutls_bye (s, how));
  52   }
  53
  54   int session::handshake ()
  55   {
  56     return RETWRAP (gnutls_handshake (s));
  57   }
  58
  59   server_session::server_session ():session (GNUTLS_SERVER)
  60   {
  61   }
  62
  63   server_session::~server_session ()
  64   {
  65   }
  66
  67   int server_session::rehandshake ()
  68   {
  69     return RETWRAP (gnutls_rehandshake (s));
  70   }
  71
  72   gnutls_alert_description_t session::get_alert () const
  73   {
  74     return gnutls_alert_get (s);
  75   }
  76
  77   int session::send_alert (gnutls_alert_level_t level,
  78                            gnutls_alert_description_t desc)
  79   {
  80     return RETWRAP (gnutls_alert_send (s, level, desc));
  81   }
  82
  83   int session::send_appropriate_alert (int err)
  84   {
  85     return RETWRAP (gnutls_alert_send_appropriate (s, err));
  86   }
  87
  88   gnutls_cipher_algorithm_t session::get_cipher () const
  89   {
  90     return gnutls_cipher_get (s);
  91   }
  92
  93   gnutls_kx_algorithm_t session::get_kx () const
  94   {
  95     return gnutls_kx_get (s);
  96   }
  97
  98   gnutls_mac_algorithm_t session::get_mac () const
  99   {
 100     return gnutls_mac_get (s);
 101   }
 102
 103   gnutls_compression_method_t session::get_compression () const
 104   {
 105     return gnutls_compression_get (s);
 106   }
 107
 108   gnutls_certificate_type_t session::get_certificate_type () const
 109   {
 110     return gnutls_certificate_type_get (s);
 111   }
 112
 113   void session::set_private_extensions (bool allow)
 114   {
 115     gnutls_handshake_set_private_extensions (s, (int) allow);
 116   }
 117
 118   gnutls_handshake_description_t session::get_handshake_last_out () const
 119   {
 120     return gnutls_handshake_get_last_out (s);
 121   }
 122
 123   gnutls_handshake_description_t session::get_handshake_last_in () const
 124   {
 125     return gnutls_handshake_get_last_in (s);
 126   }
 127
 128   ssize_t session::send (const void *data, size_t sizeofdata)
 129   {
 130     return RETWRAP (gnutls_record_send (s, data, sizeofdata));
 131   }
 132
 133   ssize_t session::recv (void *data, size_t sizeofdata)
 134   {
 135     return RETWRAP (gnutls_record_recv (s, data, sizeofdata));
 136   }
 137
 138   bool session::get_record_direction () const
 139   {
 140     return gnutls_record_get_direction (s);
 141   }
 142
 143   // maximum packet size
 144   size_t session::get_max_size () const
 145   {
 146     return gnutls_record_get_max_size (s);
 147   }
 148
 149   void session::set_max_size (size_t size)
 150   {
 151     RETWRAP (gnutls_record_set_max_size (s, size));
 152   }
 153
 154   size_t session::check_pending () const
 155   {
 156     return gnutls_record_check_pending (s);
 157   }
 158
 159
 160   void session::prf (size_t label_size, const char *label,
 161                      int server_random_first,
 162                      size_t extra_size, const char *extra,
 163                      size_t outsize, char *out)
 164   {
 165     RETWRAP (gnutls_prf (s, label_size, label, server_random_first,
 166                          extra_size, extra, outsize, out));
 167   }
 168
 169   void session::prf_raw (size_t label_size, const char *label,
 170                          size_t seed_size, const char *seed,
 171                          size_t outsize, char *out)
 172   {
 173     RETWRAP (gnutls_prf_raw
 174              (s, label_size, label, seed_size, seed, outsize, out));
 175   }
 176
 177
 178 /* if you just want some defaults, use the following.
 179  */
 180   void session::set_priority (const char *prio, const char **err_pos)
 181   {
 182     RETWRAP (gnutls_priority_set_direct (s, prio, err_pos));
 183   }
 184
 185   void session::set_priority (gnutls_priority_t p)
 186   {
 187     RETWRAP (gnutls_priority_set (s, p));
 188   }
 189
 190   gnutls_protocol_t session::get_protocol_version () const
 191   {
 192     return gnutls_protocol_get_version (s);
 193   }
 194
 195   void session::set_data (const void *session_data, size_t session_data_size)
 196   {
 197     RETWRAP (gnutls_session_set_data (s, session_data, session_data_size));
 198   }
 199
 200   void session::get_data (void *session_data, size_t * session_data_size) const
 201   {
 202     RETWRAP (gnutls_session_get_data (s, session_data, session_data_size));
 203   }
 204
 205   void session::get_data (gnutls_session_t session, gnutls_datum_t & data) const
 206   {
 207     RETWRAP (gnutls_session_get_data2 (s, &data));
 208
 209   }
 210
 211   void session::get_id (void *session_id, size_t * session_id_size) const
 212   {
 213     RETWRAP (gnutls_session_get_id (s, session_id, session_id_size));
 214   }
 215
 216   bool session::is_resumed () const
 217   {
 218     int ret = gnutls_session_is_resumed (s);
 219
 220       return (ret != 0);
 221   }
 222
 223   bool session::get_peers_certificate (std::vector < gnutls_datum_t >
 224                                        &out_certs) const
 225   {
 226     const gnutls_datum_t *certs;
 227     unsigned int certs_size;
 228
 229       certs = gnutls_certificate_get_peers (s, &certs_size);
 230
 231     if (certs == NULL)
 232       return false;
 233
 234     for (unsigned int i = 0; i < certs_size; i++)
 235       out_certs.push_back (certs[i]);
 236
 237       return true;
 238   }
 239
 240   bool session::get_peers_certificate (const gnutls_datum_t ** certs,
 241                                        unsigned int *certs_size) const
 242   {
 243     *certs = gnutls_certificate_get_peers (s, certs_size);
 244
 245     if (*certs == NULL)
 246       return false;
 247     return true;
 248   }
 249
 250   void session::get_our_certificate (gnutls_datum_t & cert) const
 251   {
 252     const gnutls_datum_t *d;
 253
 254       d = gnutls_certificate_get_ours (s);
 255     if (d == NULL)
 256       throw (exception (GNUTLS_E_INVALID_REQUEST));
 257       cert = *d;
 258   }
 259
 260   time_t session::get_peers_certificate_activation_time () const
 261   {
 262     return gnutls_certificate_activation_time_peers (s);
 263   }
 264
 265   time_t session::get_peers_certificate_expiration_time () const
 266   {
 267     return gnutls_certificate_expiration_time_peers (s);
 268   }
 269   void session::verify_peers_certificate (unsigned int &status) const
 270   {
 271     RETWRAP (gnutls_certificate_verify_peers2 (s, &status));
 272   }
 273
 274
 275   client_session::client_session ():session (GNUTLS_CLIENT)
 276   {
 277   }
 278
 279   client_session::~client_session ()
 280   {
 281   }
 282
 283 // client session
 284   void client_session::set_server_name (gnutls_server_name_type_t type,
 285                                         const void *name, size_t name_length)
 286   {
 287     RETWRAP (gnutls_server_name_set (s, type, name, name_length));
 288   }
 289
 290   bool client_session::get_request_status ()
 291   {
 292     return RETWRAP (gnutls_certificate_client_get_request_status (s));
 293   }
 294
 295 // server_session
 296   void server_session::get_server_name (void *data, size_t * data_length,
 297                                         unsigned int *type,
 298                                         unsigned int indx) const
 299   {
 300     RETWRAP (gnutls_server_name_get (s, data, data_length, type, indx));
 301   }
 302
 303 // internal DB stuff
 304   static int store_function (void *_db, gnutls_datum_t key,
 305                              gnutls_datum_t data)
 306   {
 307     try
 308     {
 309       DB *db = static_cast < DB * >(_db);
 310
 311       if (db->store (key, data) == false)
 312         return -1;
 313     }
 314     catch (...)
 315     {
 316       return -1;
 317     }
 318
 319     return 0;
 320   }
 321
 322   const static gnutls_datum_t null_datum = { NULL, 0 };
 323
 324   static gnutls_datum_t retrieve_function (void *_db, gnutls_datum_t key)
 325   {
 326     gnutls_datum_t data;
 327
 328     try
 329     {
 330       DB *db = static_cast < DB * >(_db);
 331
 332       if (db->retrieve (key, data) == false)
 333         return null_datum;
 334
 335     }
 336     catch (...)
 337     {
 338       return null_datum;
 339     }
 340
 341     return data;
 342   }
 343
 344   static int remove_function (void *_db, gnutls_datum_t key)
 345   {
 346     try
 347     {
 348       DB *db = static_cast < DB * >(_db);
 349
 350       if (db->remove (key) == false)
 351         return -1;
 352     }
 353     catch (...)
 354     {
 355       return -1;
 356     }
 357
 358     return 0;
 359   }
 360
 361   void server_session::set_db (const DB & db)
 362   {
 363     gnutls_db_set_ptr (s, const_cast < DB * >(&db));
 364     gnutls_db_set_store_function (s, store_function);
 365     gnutls_db_set_retrieve_function (s, retrieve_function);
 366     gnutls_db_set_remove_function (s, remove_function);
 367   }
 368
 369   void server_session::set_db_cache_expiration (unsigned int seconds)
 370   {
 371     gnutls_db_set_cache_expiration (s, seconds);
 372   }
 373
 374   void server_session::db_remove () const
 375   {
 376     gnutls_db_remove_session (s);
 377   }
 378
 379   bool server_session::db_check_entry (gnutls_datum_t & session_data) const
 380   {
 381     int ret = gnutls_db_check_entry (s, session_data);
 382
 383     if (ret != 0)
 384       return true;
 385     return false;
 386   }
 387
 388   void session::set_max_handshake_packet_length (size_t max)
 389   {
 390     gnutls_handshake_set_max_packet_length (s, max);
 391   }
 392
 393   void session::clear_credentials ()
 394   {
 395     gnutls_credentials_clear (s);
 396   }
 397
 398   void session::set_credentials (credentials & cred)
 399   {
 400     RETWRAP (gnutls_credentials_set (s, cred.get_type (), cred.ptr ()));
 401   }
 402
 403   const char *server_session::get_srp_username () const
 404   {
 405 #ifdef ENABLE_SRP
 406     return gnutls_srp_server_get_username (s);
 407 #else
 408     return NULL;
 409 #endif
 410   }
 411
 412   const char *server_session::get_psk_username () const
 413   {
 414     return gnutls_psk_server_get_username (s);
 415   }
 416
 417
 418   void session::set_transport_ptr (gnutls_transport_ptr_t ptr)
 419   {
 420     gnutls_transport_set_ptr (s, ptr);
 421   }
 422
 423   void session::set_transport_ptr (gnutls_transport_ptr_t recv_ptr,
 424                                    gnutls_transport_ptr_t send_ptr)
 425   {
 426     gnutls_transport_set_ptr2 (s, recv_ptr, send_ptr);
 427   }
 428
 429
 430   gnutls_transport_ptr_t session::get_transport_ptr () const
 431   {
 432     return gnutls_transport_get_ptr (s);
 433   }
 434
 435   void session::get_transport_ptr (gnutls_transport_ptr_t & recv_ptr,
 436                                    gnutls_transport_ptr_t & send_ptr) const
 437   {
 438     gnutls_transport_get_ptr2 (s, &recv_ptr, &send_ptr);
 439   }
 440
 441   void session::set_transport_lowat (size_t num)
 442   {
 443     throw (exception (GNUTLS_E_UNIMPLEMENTED_FEATURE));
 444   }
 445
 446   void session::set_transport_push_function (gnutls_push_func push_func)
 447   {
 448     gnutls_transport_set_push_function (s, push_func);
 449   }
 450
 451   void session::set_transport_vec_push_function (gnutls_vec_push_func vec_push_func)
 452   {
 453     gnutls_transport_set_vec_push_function (s, vec_push_func);
 454   }
 455
 456   void session::set_transport_pull_function (gnutls_pull_func pull_func)
 457   {
 458     gnutls_transport_set_pull_function (s, pull_func);
 459   }
 460
 461   void session::set_user_ptr (void *ptr)
 462   {
 463     gnutls_session_set_ptr (s, ptr);
 464   }
 465
 466   void *session::get_user_ptr () const
 467   {
 468     return gnutls_session_get_ptr (s);
 469   }
 470
 471   void session::send_openpgp_cert (gnutls_openpgp_crt_status_t status)
 472   {
 473 #ifdef ENABLE_OPENPGP
 474     gnutls_openpgp_send_cert (s, status);
 475 #endif
 476   }
 477
 478   void session::set_dh_prime_bits (unsigned int bits)
 479   {
 480     gnutls_dh_set_prime_bits (s, bits);
 481   }
 482
 483   unsigned int session::get_dh_secret_bits () const
 484   {
 485     return RETWRAP (gnutls_dh_get_secret_bits (s));
 486   }
 487
 488   unsigned int session::get_dh_peers_public_bits () const
 489   {
 490     return RETWRAP (gnutls_dh_get_peers_public_bits (s));
 491   }
 492
 493   unsigned int session::get_dh_prime_bits () const
 494   {
 495     return RETWRAP (gnutls_dh_get_prime_bits (s));
 496   }
 497
 498   void session::get_dh_group (gnutls_datum_t & gen,
 499                               gnutls_datum_t & prime) const
 500   {
 501     RETWRAP (gnutls_dh_get_group (s, &gen, &prime));
 502   }
 503
 504   void session::get_dh_pubkey (gnutls_datum_t & raw_key) const
 505   {
 506     RETWRAP (gnutls_dh_get_pubkey (s, &raw_key));
 507   }
 508
 509 #ifdef ENABLE_RSA_EXPORT
 510   void session::get_rsa_export_pubkey (gnutls_datum_t & exponent,
 511                                        gnutls_datum_t & modulus) const
 512   {
 513     RETWRAP (gnutls_rsa_export_get_pubkey (s, &exponent, &modulus));
 514   }
 515
 516   unsigned int session::get_rsa_export_modulus_bits () const
 517   {
 518     return RETWRAP (gnutls_rsa_export_get_modulus_bits (s));
 519   }
 520
 521   void certificate_credentials::
 522     set_rsa_export_params (const rsa_params & params)
 523   {
 524     gnutls_certificate_set_rsa_export_params (cred, params.get_params_t ());
 525   }
 526 #endif
 527
 528   void server_session::
 529     set_certificate_request (gnutls_certificate_request_t req)
 530   {
 531     gnutls_certificate_server_set_request (s, req);
 532   }
 533
 534   gnutls_credentials_type_t session::get_auth_type () const
 535   {
 536     return gnutls_auth_get_type (s);
 537   }
 538
 539   gnutls_credentials_type_t session::get_server_auth_type () const
 540   {
 541     return gnutls_auth_server_get_type (s);
 542   }
 543
 544   gnutls_credentials_type_t session::get_client_auth_type () const
 545   {
 546     return gnutls_auth_client_get_type (s);
 547   }
 548
 549
 550   certificate_credentials::~certificate_credentials ()
 551   {
 552     gnutls_certificate_free_credentials (cred);
 553   }
 554
 555   certificate_credentials::certificate_credentials ():credentials
 556     (GNUTLS_CRD_CERTIFICATE)
 557   {
 558     RETWRAP (gnutls_certificate_allocate_credentials (&cred));
 559     set_ptr (cred);
 560   }
 561
 562   void certificate_server_credentials::
 563     set_params_function (gnutls_params_function * func)
 564   {
 565     gnutls_certificate_set_params_function (cred, func);
 566   }
 567
 568   anon_server_credentials::anon_server_credentials ():credentials
 569     (GNUTLS_CRD_ANON)
 570   {
 571     RETWRAP (gnutls_anon_allocate_server_credentials (&cred));
 572     set_ptr (cred);
 573   }
 574
 575   anon_server_credentials::~anon_server_credentials ()
 576   {
 577     gnutls_anon_free_server_credentials (cred);
 578   }
 579
 580   void anon_server_credentials::set_dh_params (const dh_params & params)
 581   {
 582     gnutls_anon_set_server_dh_params (cred, params.get_params_t ());
 583   }
 584
 585   void anon_server_credentials::set_params_function (gnutls_params_function *
 586                                                      func)
 587   {
 588     gnutls_anon_set_server_params_function (cred, func);
 589   }
 590
 591   anon_client_credentials::anon_client_credentials ():credentials
 592     (GNUTLS_CRD_ANON)
 593   {
 594     RETWRAP (gnutls_anon_allocate_client_credentials (&cred));
 595     set_ptr (cred);
 596   }
 597
 598   anon_client_credentials::~anon_client_credentials ()
 599   {
 600     gnutls_anon_free_client_credentials (cred);
 601   }
 602
 603   void certificate_credentials::free_keys ()
 604   {
 605     gnutls_certificate_free_keys (cred);
 606   }
 607
 608   void certificate_credentials::free_cas ()
 609   {
 610     gnutls_certificate_free_cas (cred);
 611   }
 612
 613   void certificate_credentials::free_ca_names ()
 614   {
 615     gnutls_certificate_free_ca_names (cred);
 616   }
 617
 618   void certificate_credentials::free_crls ()
 619   {
 620     gnutls_certificate_free_crls (cred);
 621   }
 622
 623
 624   void certificate_credentials::set_dh_params (const dh_params & params)
 625   {
 626     gnutls_certificate_set_dh_params (cred, params.get_params_t ());
 627   }
 628
 629   void certificate_credentials::set_verify_flags (unsigned int flags)
 630   {
 631     gnutls_certificate_set_verify_flags (cred, flags);
 632   }
 633
 634   void certificate_credentials::set_verify_limits (unsigned int max_bits,
 635                                                    unsigned int max_depth)
 636   {
 637     gnutls_certificate_set_verify_limits (cred, max_bits, max_depth);
 638   }
 639
 640   void certificate_credentials::set_x509_trust_file (const char *cafile,
 641                                                      gnutls_x509_crt_fmt_t
 642                                                      type)
 643   {
 644     RETWRAP (gnutls_certificate_set_x509_trust_file (cred, cafile, type));
 645   }
 646
 647   void certificate_credentials::set_x509_trust (const gnutls_datum_t & CA,
 648                                                 gnutls_x509_crt_fmt_t type)
 649   {
 650     RETWRAP (gnutls_certificate_set_x509_trust_mem (cred, &CA, type));
 651   }
 652
 653
 654   void certificate_credentials::set_x509_crl_file (const char *crlfile,
 655                                                    gnutls_x509_crt_fmt_t type)
 656   {
 657     RETWRAP (gnutls_certificate_set_x509_crl_file (cred, crlfile, type));
 658   }
 659
 660   void certificate_credentials::set_x509_crl (const gnutls_datum_t & CRL,
 661                                               gnutls_x509_crt_fmt_t type)
 662   {
 663     RETWRAP (gnutls_certificate_set_x509_crl_mem (cred, &CRL, type));
 664   }
 665
 666   void certificate_credentials::set_x509_key_file (const char *certfile,
 667                                                    const char *keyfile,
 668                                                    gnutls_x509_crt_fmt_t type)
 669   {
 670     RETWRAP (gnutls_certificate_set_x509_key_file
 671              (cred, certfile, keyfile, type));
 672   }
 673
 674   void certificate_credentials::set_x509_key (const gnutls_datum_t & CERT,
 675                                               const gnutls_datum_t & KEY,
 676                                               gnutls_x509_crt_fmt_t type)
 677   {
 678     RETWRAP (gnutls_certificate_set_x509_key_mem (cred, &CERT, &KEY, type));
 679   }
 680
 681   void certificate_credentials::
 682     set_simple_pkcs12_file (const char *pkcs12file,
 683                             gnutls_x509_crt_fmt_t type, const char *password)
 684   {
 685     RETWRAP (gnutls_certificate_set_x509_simple_pkcs12_file
 686              (cred, pkcs12file, type, password));
 687   }
 688
 689   void certificate_credentials::set_x509_key (gnutls_x509_crt_t * cert_list,
 690                                               int cert_list_size,
 691                                               gnutls_x509_privkey_t key)
 692   {
 693     RETWRAP (gnutls_certificate_set_x509_key
 694              (cred, cert_list, cert_list_size, key));
 695   }
 696
 697   void certificate_credentials::set_x509_trust (gnutls_x509_crt_t * ca_list,
 698                                                 int ca_list_size)
 699   {
 700     RETWRAP (gnutls_certificate_set_x509_trust (cred, ca_list, ca_list_size));
 701   }
 702
 703   void certificate_credentials::set_x509_crl (gnutls_x509_crl_t * crl_list,
 704                                               int crl_list_size)
 705   {
 706     RETWRAP (gnutls_certificate_set_x509_crl (cred, crl_list, crl_list_size));
 707   }
 708
 709   void certificate_credentials::
 710     set_retrieve_function (gnutls_certificate_retrieve_function * func)
 711   {
 712     gnutls_certificate_set_retrieve_function (cred, func);
 713   }
 714
 715 // SRP
 716
 717 #ifdef ENABLE_SRP
 718
 719   srp_server_credentials::srp_server_credentials ():credentials
 720     (GNUTLS_CRD_SRP)
 721   {
 722     RETWRAP (gnutls_srp_allocate_server_credentials (&cred));
 723     set_ptr (cred);
 724   }
 725
 726   srp_server_credentials::~srp_server_credentials ()
 727   {
 728     gnutls_srp_free_server_credentials (cred);
 729   }
 730
 731   srp_client_credentials::srp_client_credentials ():credentials
 732     (GNUTLS_CRD_SRP)
 733   {
 734     RETWRAP (gnutls_srp_allocate_client_credentials (&cred));
 735     set_ptr (cred);
 736   }
 737
 738   srp_client_credentials::~srp_client_credentials ()
 739   {
 740     gnutls_srp_free_client_credentials (cred);
 741   }
 742
 743   void srp_client_credentials::set_credentials (const char *username,
 744                                                 const char *password)
 745   {
 746     RETWRAP (gnutls_srp_set_client_credentials (cred, username, password));
 747   }
 748
 749   void srp_server_credentials::
 750     set_credentials_file (const char *password_file,
 751                           const char *password_conf_file)
 752   {
 753     RETWRAP (gnutls_srp_set_server_credentials_file
 754              (cred, password_file, password_conf_file));
 755   }
 756
 757   void srp_server_credentials::
 758     set_credentials_function (gnutls_srp_server_credentials_function * func)
 759   {
 760     gnutls_srp_set_server_credentials_function (cred, func);
 761   }
 762
 763   void srp_client_credentials::
 764     set_credentials_function (gnutls_srp_client_credentials_function * func)
 765   {
 766     gnutls_srp_set_client_credentials_function (cred, func);
 767   }
 768
 769 #endif /* ENABLE_SRP */
 770
 771 // PSK
 772
 773 psk_server_credentials::psk_server_credentials ():credentials
 774     (GNUTLS_CRD_PSK)
 775   {
 776     RETWRAP (gnutls_psk_allocate_server_credentials (&cred));
 777     set_ptr (cred);
 778   }
 779
 780   psk_server_credentials::~psk_server_credentials ()
 781   {
 782     gnutls_psk_free_server_credentials (cred);
 783   }
 784
 785   void psk_server_credentials::
 786     set_credentials_file (const char *password_file)
 787   {
 788     RETWRAP (gnutls_psk_set_server_credentials_file (cred, password_file));
 789   }
 790
 791   void psk_server_credentials::
 792     set_credentials_function (gnutls_psk_server_credentials_function * func)
 793   {
 794     gnutls_psk_set_server_credentials_function (cred, func);
 795   }
 796
 797   void psk_server_credentials::set_dh_params (const dh_params & params)
 798   {
 799     gnutls_psk_set_server_dh_params (cred, params.get_params_t ());
 800   }
 801
 802   void psk_server_credentials::set_params_function (gnutls_params_function *
 803                                                     func)
 804   {
 805     gnutls_psk_set_server_params_function (cred, func);
 806   }
 807
 808   psk_client_credentials::psk_client_credentials ():credentials
 809     (GNUTLS_CRD_PSK)
 810   {
 811     RETWRAP (gnutls_psk_allocate_client_credentials (&cred));
 812     set_ptr (cred);
 813   }
 814
 815   psk_client_credentials::~psk_client_credentials ()
 816   {
 817     gnutls_psk_free_client_credentials (cred);
 818   }
 819
 820   void psk_client_credentials::set_credentials (const char *username,
 821                                                 const gnutls_datum_t & key,
 822                                                 gnutls_psk_key_flags flags)
 823   {
 824     RETWRAP (gnutls_psk_set_client_credentials (cred, username, &key, flags));
 825   }
 826
 827   void psk_client_credentials::
 828     set_credentials_function (gnutls_psk_client_credentials_function * func)
 829   {
 830     gnutls_psk_set_client_credentials_function (cred, func);
 831   }
 832
 833   credentials::credentials (gnutls_credentials_type_t t):type (t),
 834     cred (NULL)
 835   {
 836   }
 837
 838   gnutls_credentials_type_t credentials::get_type () const
 839   {
 840     return type;
 841   }
 842
 843   void *credentials::ptr () const
 844   {
 845     return cred;
 846   }
 847
 848   void credentials::set_ptr (void *ptr)
 849   {
 850     cred = ptr;
 851   }
 852
 853   exception::exception (int x)
 854   {
 855     retcode = x;
 856   }
 857
 858   int exception::get_code ()
 859   {
 860     return retcode;
 861   }
 862
 863   const char *exception::what () const throw ()
 864   {
 865     return gnutls_strerror (retcode);
 866   }
 867
 868   dh_params::dh_params ()
 869   {
 870     RETWRAP (gnutls_dh_params_init (&params));
 871   }
 872
 873   dh_params::~dh_params ()
 874   {
 875     gnutls_dh_params_deinit (params);
 876   }
 877
 878   void dh_params::import_raw (const gnutls_datum_t & prime,
 879                               const gnutls_datum_t & generator)
 880   {
 881     RETWRAP (gnutls_dh_params_import_raw (params, &prime, &generator));
 882   }
 883
 884   void dh_params::import_pkcs3 (const gnutls_datum_t & pkcs3_params,
 885                                 gnutls_x509_crt_fmt_t format)
 886   {
 887     RETWRAP (gnutls_dh_params_import_pkcs3 (params, &pkcs3_params, format));
 888   }
 889
 890   void dh_params::generate (unsigned int bits)
 891   {
 892     RETWRAP (gnutls_dh_params_generate2 (params, bits));
 893   }
 894
 895   void dh_params::export_pkcs3 (gnutls_x509_crt_fmt_t format,
 896                                 unsigned char *params_data,
 897                                 size_t * params_data_size)
 898   {
 899     RETWRAP (gnutls_dh_params_export_pkcs3
 900              (params, format, params_data, params_data_size));
 901   }
 902
 903   void dh_params::export_raw (gnutls_datum_t & prime,
 904                               gnutls_datum_t & generator)
 905   {
 906     RETWRAP (gnutls_dh_params_export_raw (params, &prime, &generator, NULL));
 907   }
 908
 909   gnutls_dh_params_t dh_params::get_params_t () const
 910   {
 911     return params;
 912   }
 913
 914   dh_params & dh_params::operator= (const dh_params & src)
 915   {
 916     dh_params *dst = new dh_params;
 917     int ret;
 918
 919     ret = gnutls_dh_params_cpy (dst->params, src.params);
 920
 921     if (ret < 0)
 922       {
 923         delete dst;
 924         throw (exception (ret));
 925       }
 926
 927     return *dst;
 928   }
 929
 930 // RSA
 931
 932 #ifdef ENABLE_RSA_EXPORT
 933   rsa_params::rsa_params ()
 934   {
 935     RETWRAP (gnutls_rsa_params_init (&params));
 936   }
 937
 938   rsa_params::~rsa_params ()
 939   {
 940     gnutls_rsa_params_deinit (params);
 941   }
 942
 943   void rsa_params::import_pkcs1 (const gnutls_datum_t & pkcs1_params,
 944                                  gnutls_x509_crt_fmt_t format)
 945   {
 946     RETWRAP (gnutls_rsa_params_import_pkcs1 (params, &pkcs1_params, format));
 947   }
 948
 949   void rsa_params::generate (unsigned int bits)
 950   {
 951     RETWRAP (gnutls_rsa_params_generate2 (params, bits));
 952   }
 953
 954   void rsa_params::export_pkcs1 (gnutls_x509_crt_fmt_t format,
 955                                  unsigned char *params_data,
 956                                  size_t * params_data_size)
 957   {
 958     RETWRAP (gnutls_rsa_params_export_pkcs1
 959              (params, format, params_data, params_data_size));
 960   }
 961
 962   gnutls_rsa_params_t rsa_params::get_params_t () const
 963   {
 964     return params;
 965   }
 966
 967   rsa_params & rsa_params::operator= (const rsa_params & src)
 968   {
 969     rsa_params *dst = new rsa_params;
 970     int ret;
 971
 972     ret = gnutls_rsa_params_cpy (dst->params, src.params);
 973
 974     if (ret < 0)
 975       {
 976         delete dst;
 977         throw (exception (ret));
 978       }
 979
 980     return *dst;
 981   }
 982
 983   void rsa_params::import_raw (const gnutls_datum_t & m,
 984                                const gnutls_datum_t & e,
 985                                const gnutls_datum_t & d,
 986                                const gnutls_datum_t & p,
 987                                const gnutls_datum_t & q,
 988                                const gnutls_datum_t & u)
 989   {
 990
 991     RETWRAP (gnutls_rsa_params_import_raw (params, &m, &e, &d, &p, &q, &u));
 992   }
 993
 994
 995   void rsa_params::export_raw (gnutls_datum_t & m, gnutls_datum_t & e,
 996                                gnutls_datum_t & d, gnutls_datum_t & p,
 997                                gnutls_datum_t & q, gnutls_datum_t & u)
 998   {
 999     RETWRAP (gnutls_rsa_params_export_raw
1000              (params, &m, &e, &d, &p, &q, &u, NULL));
1001   }
1002 #endif
1003 }                               // namespace gnutls