lib/gnutlsxx.cpp

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