← Back to branch summary

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

« back to all changes in this revision

Viewing changes to tests/x509self.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/x509self.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
 
55
57
/* A very basic TLS client, with anonymous authentication.
56
58
 */
57
59
 
 
60
 
58
61
#define MAX_BUF 1024
59
62
#define MSG "Hello TLS"
60
63
 
127
130
   */
128
131
  gnutls_certificate_set_x509_trust_mem (xcred, &ca, GNUTLS_X509_FMT_PEM);
129
132
  gnutls_certificate_set_x509_key_mem (xcred, &cert, &key,
130
 
                                       GNUTLS_X509_FMT_PEM);
 
133
                                       GNUTLS_X509_FMT_PEM);
131
134
 
132
135
  /* Initialize TLS session
133
136
   */
163
166
 
164
167
  if (debug)
165
168
    success ("client: TLS version is: %s\n",
166
 
             gnutls_protocol_get_name (gnutls_protocol_get_version
167
 
                                       (session)));
 
169
             gnutls_protocol_get_name (gnutls_protocol_get_version
 
170
                                       (session)));
168
171
 
169
172
  /* see the Getting peer's information example */
170
173
  if (debug)
175
178
  if (ret == strlen (MSG))
176
179
    {
177
180
      if (debug)
178
 
        success ("client: sent record.\n");
 
181
        success ("client: sent record.\n");
179
182
    }
180
183
  else
181
184
    {
192
195
  if (ret == GNUTLS_E_REHANDSHAKE)
193
196
    {
194
197
      if (debug)
195
 
        success ("client: doing handshake!\n");
 
198
        success ("client: doing handshake!\n");
196
199
      ret = gnutls_handshake (session);
197
200
      if (ret == 0)
198
 
        {
199
 
          if (debug)
200
 
            success ("client: handshake complete, reading again.\n");
201
 
          ret = gnutls_record_recv (session, buffer, MAX_BUF);
202
 
        }
 
201
        {
 
202
          if (debug)
 
203
            success ("client: handshake complete, reading again.\n");
 
204
          ret = gnutls_record_recv (session, buffer, MAX_BUF);
 
205
        }
203
206
      else
204
 
        {
205
 
          fail ("client: handshake failed.\n");
206
 
        }
 
207
        {
 
208
          fail ("client: handshake failed.\n");
 
209
        }
207
210
    }
208
211
 
209
212
  if (ret == 0)
210
213
    {
211
214
      if (debug)
212
 
        success ("client: Peer has closed the TLS connection\n");
 
215
        success ("client: Peer has closed the TLS connection\n");
213
216
      goto end;
214
217
    }
215
218
  else if (ret < 0)
222
225
    {
223
226
      printf ("- Received %d bytes: ", ret);
224
227
      for (ii = 0; ii < ret; ii++)
225
 
        {
226
 
          fputc (buffer[ii], stdout);
227
 
        }
 
228
        {
 
229
          fputc (buffer[ii], stdout);
 
230
        }
228
231
      fputs ("\n", stdout);
229
232
    }
230
233
 
246
249
 
247
250
#define SA struct sockaddr
248
251
#define MAX_BUF 1024
249
 
#define PORT 5556               /* listen to 5556 port */
 
252
#define PORT 5556               /* listen to 5556 port */
250
253
#define DH_BITS 1024
251
254
 
252
255
/* These are global */
359
362
  memset (&sa_serv, '\0', sizeof (sa_serv));
360
363
  sa_serv.sin_family = AF_INET;
361
364
  sa_serv.sin_addr.s_addr = INADDR_ANY;
362
 
  sa_serv.sin_port = htons (PORT);      /* Server Port number */
 
365
  sa_serv.sin_port = htons (PORT);      /* Server Port number */
363
366
 
364
367
  setsockopt (listen_sd, SOL_SOCKET, SO_REUSEADDR, (void *) &optval,
365
 
              sizeof (int));
 
368
              sizeof (int));
366
369
 
367
370
  err = bind (listen_sd, (SA *) & sa_serv, sizeof (sa_serv));
368
371
  if (err == -1)
399
402
  gnutls_certificate_set_x509_trust_mem (x509_cred, &ca, GNUTLS_X509_FMT_PEM);
400
403
 
401
404
  gnutls_certificate_set_x509_key_mem (x509_cred, &server_cert, &server_key,
402
 
                                       GNUTLS_X509_FMT_PEM);
 
405
                                       GNUTLS_X509_FMT_PEM);
403
406
 
404
407
  if (debug)
405
408
    success ("Launched, generating DH parameters...\n");
416
419
 
417
420
  if (debug)
418
421
    success ("server: connection from %s, port %d\n",
419
 
             inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
420
 
                        sizeof (topbuf)), ntohs (sa_cli.sin_port));
 
422
             inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
 
423
                        sizeof (topbuf)), ntohs (sa_cli.sin_port));
421
424
 
422
425
  gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
423
426
  ret = gnutls_handshake (session);
432
435
    {
433
436
      success ("server: Handshake was completed\n");
434
437
      success ("server: TLS version is: %s\n",
435
 
               gnutls_protocol_get_name (gnutls_protocol_get_version
436
 
                                         (session)));
 
438
               gnutls_protocol_get_name (gnutls_protocol_get_version
 
439
                                         (session)));
437
440
    }
438
441
 
439
442
  /* see the Getting peer's information example */
447
450
      ret = gnutls_record_recv (session, buffer, MAX_BUF);
448
451
 
449
452
      if (ret == 0)
450
 
        {
451
 
          if (debug)
452
 
            success ("server: Peer has closed the GnuTLS connection\n");
453
 
          break;
454
 
        }
 
453
        {
 
454
          if (debug)
 
455
            success ("server: Peer has closed the GnuTLS connection\n");
 
456
          break;
 
457
        }
455
458
      else if (ret < 0)
456
 
        {
457
 
          fail ("server: Received corrupted data(%d). Closing...\n", ret);
458
 
          break;
459
 
        }
 
459
        {
 
460
          fail ("server: Received corrupted data(%d). Closing...\n", ret);
 
461
          break;
 
462
        }
460
463
      else if (ret > 0)
461
 
        {
462
 
          gnutls_certificate_server_set_request (session,
463
 
                                                 GNUTLS_CERT_REQUEST);
464
 
 
465
 
          if (debug)
466
 
            success ("server: got data, forcing rehandshake.\n");
467
 
 
468
 
          ret = gnutls_rehandshake (session);
469
 
          if (ret < 0)
470
 
            {
471
 
              fail ("server: rehandshake failed\n");
472
 
              gnutls_perror (ret);
473
 
              break;
474
 
            }
475
 
 
476
 
          ret = gnutls_handshake (session);
477
 
          if (ret < 0)
478
 
            {
479
 
              fail ("server: (re)handshake failed\n");
480
 
              gnutls_perror (ret);
481
 
              break;
482
 
            }
483
 
 
484
 
          if (debug)
485
 
            success ("server: rehandshake complete.\n");
486
 
 
487
 
          /* echo data back to the client
488
 
           */
489
 
          gnutls_record_send (session, buffer, strlen (buffer));
490
 
        }
 
464
        {
 
465
          gnutls_certificate_server_set_request (session,
 
466
                                                 GNUTLS_CERT_REQUEST);
 
467
 
 
468
          if (debug)
 
469
            success ("server: got data, forcing rehandshake.\n");
 
470
 
 
471
          ret = gnutls_rehandshake (session);
 
472
          if (ret < 0)
 
473
            {
 
474
              fail ("server: rehandshake failed\n");
 
475
              gnutls_perror (ret);
 
476
              break;
 
477
            }
 
478
 
 
479
          ret = gnutls_handshake (session);
 
480
          if (ret < 0)
 
481
            {
 
482
              fail ("server: (re)handshake failed\n");
 
483
              gnutls_perror (ret);
 
484
              break;
 
485
            }
 
486
 
 
487
          if (debug)
 
488
            success ("server: rehandshake complete.\n");
 
489
 
 
490
          /* echo data back to the client
 
491
           */
 
492
          gnutls_record_send (session, buffer, strlen (buffer));
 
493
        }
491
494
    }
492
495
  /* do not wait for the peer to close the connection.
493
496
   */