← Back to branch summary

~ubuntu-branches/ubuntu/quantal/gnutls26/quantal-security

« back to all changes in this revision

Viewing changes to tests/x509dn.c

  • Committer: Package Import Robot
  • Author(s): Andreas Metzler
  • Date: 2011-10-01 15:28:13 UTC
  • mfrom: (12.1.20 sid)
  • Revision ID: package-import@ubuntu.com-20111001152813-yygm1c4cxonfxhzy
Tags: 2.12.11-1
http://bugs.debian.org/640639
* New upstream version.
  + Allow CA importing of 0 certificates to succeed. Closes: #640639
* Add libp11-kit-dev to libgnutls-dev dependencies. (see #643811)
* [20_guiledocstring.diff] guile: Fix docstring extraction with CPP 4.5+.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/x509dn.c
24
24
/* Parts copied from GnuTLS example programs. */
25
25
 
26
26
#ifdef HAVE_CONFIG_H
27
 
# include <config.h>
 
27
#include <config.h>
28
28
#endif
29
29
 
30
30
#include <stdio.h>
31
31
#include <stdlib.h>
32
32
#include <string.h>
33
33
#include <sys/types.h>
 
34
#if !defined(_WIN32)
34
35
#include <netinet/in.h>
35
36
#include <sys/socket.h>
36
37
#include <sys/wait.h>
37
38
#include <arpa/inet.h>
 
39
#endif
38
40
#include <unistd.h>
39
41
#include <gnutls/gnutls.h>
40
42
 
111
113
 
112
114
static int
113
115
cert_callback (gnutls_session_t session,
114
 
               const gnutls_datum_t * req_ca_rdn, int nreqs,
115
 
               const gnutls_pk_algorithm_t * sign_algos,
116
 
               int sign_algos_length, gnutls_retr_st * st)
 
116
               const gnutls_datum_t * req_ca_rdn, int nreqs,
 
117
               const gnutls_pk_algorithm_t * sign_algos,
 
118
               int sign_algos_length, gnutls_retr2_st * st)
117
119
{
118
120
  int result;
119
121
  gnutls_x509_dn_t dn;
140
142
      gnutls_x509_ava_st val;
141
143
 
142
144
      if (debug)
143
 
        success ("client: imported DN.\n");
 
145
        success ("client: imported DN.\n");
144
146
 
145
147
      if (gnutls_x509_dn_get_rdn_ava (dn, 0, 0, &val) == 0)
146
 
        {
147
 
          if (debug)
148
 
            success ("client: got RDN 0.\n");
 
148
        {
 
149
          if (debug)
 
150
            success ("client: got RDN 0.\n");
149
151
 
150
 
          if (val.value.size == strlen (EXPECT_RDN0)
151
 
              && strncmp (val.value.data, EXPECT_RDN0, val.value.size) == 0)
152
 
            {
153
 
              if (debug)
154
 
                success ("client: RND 0 correct.\n");
155
 
            }
156
 
          else
157
 
            {
158
 
              fail ("client: RND 0 bad: %.*s\n",
159
 
                    val.value.size, val.value.data);
160
 
              return -1;
161
 
            }
162
 
        }
 
152
          if (val.value.size == strlen (EXPECT_RDN0)
 
153
              && strncmp (val.value.data, EXPECT_RDN0, val.value.size) == 0)
 
154
            {
 
155
              if (debug)
 
156
                success ("client: RND 0 correct.\n");
 
157
            }
 
158
          else
 
159
            {
 
160
              fail ("client: RND 0 bad: %.*s\n",
 
161
                    val.value.size, val.value.data);
 
162
              return -1;
 
163
            }
 
164
        }
163
165
      else
164
 
        {
165
 
          fail ("client: could not retrieve RDN 0.\n");
166
 
          return -1;
167
 
        }
 
166
        {
 
167
          fail ("client: could not retrieve RDN 0.\n");
 
168
          return -1;
 
169
        }
168
170
 
169
171
      gnutls_x509_dn_deinit (dn);
170
172
    }
197
199
   */
198
200
  gnutls_certificate_set_x509_trust_mem (xcred, &ca, GNUTLS_X509_FMT_PEM);
199
201
 
200
 
  gnutls_certificate_client_set_retrieve_function (xcred, cert_callback);
 
202
  gnutls_certificate_set_retrieve_function (xcred, cert_callback);
201
203
 
202
204
  /* Initialize TLS session
203
205
   */
229
231
  else
230
232
    {
231
233
      if (debug)
232
 
        success ("client: Handshake was completed\n");
 
234
        success ("client: Handshake was completed\n");
233
235
    }
234
236
 
235
237
  if (debug)
236
238
    success ("client: TLS version is: %s\n",
237
 
             gnutls_protocol_get_name (gnutls_protocol_get_version
238
 
                                       (session)));
 
239
             gnutls_protocol_get_name (gnutls_protocol_get_version
 
240
                                       (session)));
239
241
 
240
242
  /* see the Getting peer's information example */
241
243
  if (debug)
247
249
  if (ret == 0)
248
250
    {
249
251
      if (debug)
250
 
        success ("client: Peer has closed the TLS connection\n");
 
252
        success ("client: Peer has closed the TLS connection\n");
251
253
      goto end;
252
254
    }
253
255
  else if (ret < 0)
260
262
    {
261
263
      printf ("- Received %d bytes: ", ret);
262
264
      for (ii = 0; ii < ret; ii++)
263
 
        {
264
 
          fputc (buffer[ii], stdout);
265
 
        }
 
265
        {
 
266
          fputc (buffer[ii], stdout);
 
267
        }
266
268
      fputs ("\n", stdout);
267
269
    }
268
270
 
284
286
 
285
287
#define SA struct sockaddr
286
288
#define MAX_BUF 1024
287
 
#define PORT 5556               /* listen to 5556 port */
 
289
#define PORT 5556               /* listen to 5556 port */
288
290
#define DH_BITS 1024
289
291
 
290
292
/* These are global */
396
398
  memset (&sa_serv, '\0', sizeof (sa_serv));
397
399
  sa_serv.sin_family = AF_INET;
398
400
  sa_serv.sin_addr.s_addr = INADDR_ANY;
399
 
  sa_serv.sin_port = htons (PORT);      /* Server Port number */
 
401
  sa_serv.sin_port = htons (PORT);      /* Server Port number */
400
402
 
401
403
  setsockopt (listen_sd, SOL_SOCKET, SO_REUSEADDR, (void *) &optval,
402
 
              sizeof (int));
 
404
              sizeof (int));
403
405
 
404
406
  err = bind (listen_sd, (SA *) & sa_serv, sizeof (sa_serv));
405
407
  if (err == -1)
436
438
  gnutls_certificate_set_x509_trust_mem (x509_cred, &ca, GNUTLS_X509_FMT_PEM);
437
439
 
438
440
  gnutls_certificate_set_x509_key_mem (x509_cred, &server_cert, &server_key,
439
 
                                       GNUTLS_X509_FMT_PEM);
 
441
                                       GNUTLS_X509_FMT_PEM);
440
442
 
441
443
  if (debug)
442
444
    success ("Launched, generating DH parameters...\n");
453
455
 
454
456
  if (debug)
455
457
    success ("server: connection from %s, port %d\n",
456
 
             inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
457
 
                        sizeof (topbuf)), ntohs (sa_cli.sin_port));
 
458
             inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
 
459
                        sizeof (topbuf)), ntohs (sa_cli.sin_port));
458
460
 
459
461
  gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
460
462
  ret = gnutls_handshake (session);
470
472
 
471
473
  if (debug)
472
474
    success ("server: TLS version is: %s\n",
473
 
             gnutls_protocol_get_name (gnutls_protocol_get_version
474
 
                                       (session)));
 
475
             gnutls_protocol_get_name (gnutls_protocol_get_version
 
476
                                       (session)));
475
477
 
476
478
  /* see the Getting peer's information example */
477
479
  if (debug)
484
486
      ret = gnutls_record_recv (session, buffer, MAX_BUF);
485
487
 
486
488
      if (ret == 0)
487
 
        {
488
 
          if (debug)
489
 
            success ("server: Peer has closed the GnuTLS connection\n");
490
 
          break;
491
 
        }
 
489
        {
 
490
          if (debug)
 
491
            success ("server: Peer has closed the GnuTLS connection\n");
 
492
          break;
 
493
        }
492
494
      else if (ret < 0)
493
 
        {
494
 
          fail ("server: Received corrupted data(%d). Closing...\n", ret);
495
 
          break;
496
 
        }
 
495
        {
 
496
          fail ("server: Received corrupted data(%d). Closing...\n", ret);
 
497
          break;
 
498
        }
497
499
      else if (ret > 0)
498
 
        {
499
 
          /* echo data back to the client
500
 
           */
501
 
          gnutls_record_send (session, buffer, strlen (buffer));
502
 
        }
 
500
        {
 
501
          /* echo data back to the client
 
502
           */
 
503
          gnutls_record_send (session, buffer, strlen (buffer));
 
504
        }
503
505
    }
504
506
  /* do not wait for the peer to close the connection.
505
507
   */
545
547
 
546
548
#if defined WIFEXITED && defined WEXITSTATUS
547
549
      if (WIFEXITED (status) && WEXITSTATUS (status))
548
 
        {
549
 
          fail ("server: client failed with exit status %d\n",
550
 
                WEXITSTATUS (status));
551
 
        }
 
550
        {
 
551
          fail ("server: client failed with exit status %d\n",
 
552
                WEXITSTATUS (status));
 
553
        }
552
554
#endif
553
555
 
554
556
#if defined WIFSIGNALED && defined WTERMSIG
555
557
      if (WIFSIGNALED (status))
556
 
        {
557
 
          fail ("server: client failed with fatal signal %d\n",
558
 
                WTERMSIG (status));
559
 
        }
 
558
        {
 
559
          fail ("server: client failed with fatal signal %d\n",
 
560
                WTERMSIG (status));
 
561
        }
560
562
#endif
561
563
 
562
564
    }