lib/gnutlsxx.cpp

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