lib/gnutlsxx.cpp

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