changed license headers to 2.1. Reported by Andreas Metzler.
[gnutls:gnutls.git] / 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