dtlsEcho/dtlsEchoClient.c

   1 /*
   2  * Copyright (c) 2011-2014 Apple Inc. All Rights Reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23
  24
  25 #include <Security/Security.h>
  26 #include <Security/SecBase.h>
  27
  28 #include "../sslViewer/sslAppUtils.h"
  29
  30 #include <stdlib.h>
  31 #include <sys/types.h>
  32 #include <sys/socket.h>
  33 #include <netinet/in.h>
  34 #include <arpa/inet.h>
  35 #include <stdio.h>
  36 #include <errno.h>
  37 #include <unistd.h> /* close() */
  38 #include <string.h> /* memset() */
  39 #include <fcntl.h>
  40 #include <time.h>
  41
  42 #ifdef NO_SERVER
  43 #include <securityd/spi.h>
  44 #endif
  45
  46 static
  47 unsigned char ServerRSA_Key_der[] = {
  48     0x30, 0x82, 0x02, 0x5b, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xab,
  49     0x05, 0xba, 0xdc, 0x2d, 0xb3, 0x03, 0xf1, 0x6c, 0x60, 0x7f, 0x5e, 0x80,
  50     0x85, 0x54, 0x24, 0xc7, 0x87, 0x6e, 0xe5, 0xf1, 0xae, 0x76, 0x59, 0xe3,
  51     0x4b, 0x9c, 0xff, 0xa2, 0x41, 0xfc, 0x40, 0xf8, 0xa8, 0x33, 0x12, 0xa9,
  52     0x1b, 0x1a, 0xc5, 0xe8, 0xef, 0xb1, 0xe3, 0x75, 0x0b, 0xd2, 0x28, 0x49,
  53     0x48, 0x64, 0x9c, 0x3d, 0x89, 0xb6, 0xf8, 0xa5, 0x93, 0xd0, 0x29, 0x8c,
  54     0x9e, 0x7a, 0xf6, 0x00, 0x20, 0x08, 0x52, 0x08, 0xdc, 0x1d, 0x17, 0x8b,
  55     0x44, 0x4e, 0x32, 0x13, 0xdc, 0xb1, 0x50, 0xa5, 0xf0, 0x94, 0x25, 0x50,
  56     0xfa, 0x1e, 0xe3, 0xae, 0x66, 0x19, 0x13, 0x3e, 0x20, 0x86, 0x05, 0x9c,
  57     0xda, 0xd9, 0xff, 0x8f, 0x72, 0x6e, 0xf5, 0xc1, 0xfd, 0x86, 0xae, 0x26,
  58     0xcc, 0x4b, 0xc8, 0x9f, 0xa9, 0xd6, 0x3a, 0x1f, 0xb6, 0x8a, 0x8f, 0x04,
  59     0x2d, 0xbb, 0xa4, 0x47, 0xb3, 0xfb, 0xf9, 0x02, 0x03, 0x01, 0x00, 0x01,
  60     0x02, 0x81, 0x80, 0x38, 0x04, 0xf1, 0x77, 0x4b, 0xb4, 0xd6, 0xb6, 0xce,
  61     0xf4, 0x30, 0xe4, 0x68, 0x9e, 0xc3, 0xb8, 0x24, 0x6f, 0x75, 0x60, 0xf6,
  62     0xb0, 0x59, 0xee, 0x09, 0xa8, 0xeb, 0xed, 0x44, 0x5d, 0xee, 0xdd, 0xed,
  63     0x55, 0x53, 0x1d, 0x6a, 0xad, 0x09, 0x31, 0x08, 0xa2, 0xf3, 0x16, 0xf9,
  64     0x70, 0xfc, 0xce, 0xdb, 0x6a, 0x4e, 0x22, 0x6b, 0x79, 0xdf, 0xa8, 0x44,
  65     0xbc, 0x4d, 0x34, 0x3e, 0xee, 0x6e, 0x81, 0xfa, 0xe5, 0xf4, 0x62, 0x95,
  66     0x30, 0xce, 0x49, 0x11, 0x42, 0x2b, 0x2e, 0x6a, 0x87, 0x0c, 0x6a, 0x1f,
  67     0xaf, 0x22, 0xec, 0x32, 0x6b, 0x3e, 0x1b, 0xc3, 0xcb, 0xb4, 0x46, 0xd6,
  68     0x14, 0xd0, 0x52, 0x6b, 0x4c, 0x63, 0x74, 0xcb, 0xbe, 0xeb, 0xf8, 0xbf,
  69     0x31, 0xd6, 0xe3, 0x42, 0x1f, 0x77, 0x68, 0xf2, 0xf2, 0xf0, 0xf4, 0x24,
  70     0x10, 0x5f, 0x9c, 0x3c, 0x5c, 0xbb, 0x5b, 0x19, 0xed, 0x30, 0x01, 0x02,
  71     0x41, 0x00, 0xd2, 0x72, 0x8b, 0xd9, 0x1a, 0x8d, 0xcb, 0xa2, 0x56, 0x6b,
  72     0x3b, 0x78, 0xf3, 0x7a, 0xd4, 0x97, 0x90, 0xcd, 0xcd, 0x5a, 0x32, 0x06,
  73     0x3d, 0xb0, 0xc2, 0xfb, 0x9f, 0x95, 0x51, 0x63, 0xcf, 0xcd, 0x5c, 0xcb,
  74     0x4b, 0xa7, 0xe5, 0x5f, 0xd0, 0xd3, 0x5a, 0xc8, 0x92, 0xe1, 0xde, 0xe0,
  75     0x83, 0x86, 0xfe, 0xdd, 0xe1, 0xb4, 0x00, 0x72, 0x25, 0xb4, 0x20, 0x19,
  76     0xf6, 0x94, 0xf8, 0xfd, 0x4e, 0x01, 0x02, 0x41, 0x00, 0xd0, 0x0a, 0x89,
  77     0x2a, 0x99, 0x49, 0x35, 0x60, 0x14, 0x8d, 0x2c, 0xe7, 0x72, 0xa0, 0x19,
  78     0xd6, 0x86, 0x60, 0x0d, 0xa6, 0x44, 0x89, 0x30, 0x98, 0xea, 0xeb, 0xdf,
  79     0xfb, 0xb5, 0x56, 0x23, 0x3c, 0xe4, 0xc9, 0x76, 0x4f, 0x90, 0x8e, 0x55,
  80     0x7d, 0x51, 0xcb, 0x41, 0xf1, 0x73, 0xb0, 0xa9, 0x8b, 0x36, 0xf9, 0x1a,
  81     0xfe, 0x6f, 0xa3, 0x2e, 0x13, 0x30, 0xc4, 0xe3, 0x2c, 0x51, 0x7d, 0x1d,
  82     0xf9, 0x02, 0x40, 0x6e, 0x72, 0x55, 0x79, 0x04, 0x99, 0xa4, 0x64, 0xb7,
  83     0x8c, 0x21, 0xb3, 0x51, 0xbd, 0x86, 0x33, 0x61, 0x78, 0xd1, 0x2c, 0x64,
  84     0x12, 0xa8, 0x6f, 0xcb, 0x75, 0x39, 0x84, 0xa9, 0x29, 0x84, 0x16, 0xd8,
  85     0x7b, 0x8d, 0x62, 0x39, 0x5c, 0x77, 0x01, 0x65, 0xa4, 0xdc, 0x89, 0x94,
  86     0x6a, 0x2a, 0x3d, 0x40, 0x27, 0x7c, 0xdb, 0xf6, 0x5b, 0xf1, 0xf3, 0xbd,
  87     0xe1, 0x42, 0x6b, 0x5e, 0xdd, 0xba, 0x01, 0x02, 0x40, 0x6b, 0x56, 0x14,
  88     0x41, 0x23, 0x47, 0x2f, 0x3f, 0xbc, 0x3a, 0xbe, 0x81, 0x47, 0x95, 0xac,
  89     0xdf, 0x0f, 0x03, 0x7d, 0xe7, 0x5c, 0x13, 0x00, 0x3c, 0xd5, 0x70, 0x0f,
  90     0x67, 0x19, 0xbf, 0x30, 0x7d, 0x19, 0x79, 0x8c, 0x0e, 0x2f, 0x02, 0x10,
  91     0xbf, 0x90, 0xb4, 0xf2, 0xf7, 0xf5, 0x7d, 0x9f, 0x6c, 0x11, 0x57, 0xe3,
  92     0x02, 0x85, 0x6c, 0xc6, 0xb7, 0xe6, 0x00, 0x9f, 0x48, 0xdd, 0x5e, 0x55,
  93     0x59, 0x02, 0x40, 0x51, 0xb5, 0xaf, 0x36, 0x4b, 0x91, 0x6c, 0x89, 0x19,
  94     0x44, 0x96, 0x6c, 0x4a, 0x94, 0x58, 0x29, 0x5c, 0x38, 0xd4, 0x6b, 0x24,
  95     0xdc, 0x3b, 0xb1, 0x66, 0xc1, 0x3c, 0xc8, 0x17, 0x97, 0xb7, 0x05, 0xd9,
  96     0x18, 0xb6, 0x43, 0x16, 0xf8, 0xf9, 0x5e, 0xed, 0x7e, 0x6f, 0xc4, 0xa6,
  97     0x6a, 0x3a, 0xc7, 0xc0, 0x21, 0x6b, 0x39, 0xac, 0xf3, 0xf6, 0x40, 0xd5,
  98     0x25, 0xf7, 0x44, 0x1d, 0xd4, 0xb2, 0x37
  99 };
 100
 101 static
 102 unsigned char ServerRSA_Cert_CA_RSA_der[] = {
 103     0x30, 0x82, 0x02, 0x69, 0x30, 0x82, 0x01, 0x51, 0xa0, 0x03, 0x02, 0x01,
 104     0x02, 0x02, 0x01, 0x01, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86,
 105     0xf7, 0x0d, 0x01, 0x01, 0x05, 0x05, 0x00, 0x30, 0x25, 0x31, 0x23, 0x30,
 106     0x21, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x1a, 0x53, 0x65, 0x63, 0x75,
 107     0x72, 0x69, 0x74, 0x79, 0x54, 0x65, 0x73, 0x74, 0x20, 0x43, 0x41, 0x20,
 108     0x43, 0x65, 0x72, 0x74, 0x20, 0x28, 0x52, 0x53, 0x41, 0x29, 0x30, 0x20,
 109     0x17, 0x0d, 0x31, 0x35, 0x30, 0x33, 0x32, 0x33, 0x30, 0x37, 0x31, 0x30,
 110     0x32, 0x36, 0x5a, 0x18, 0x0f, 0x32, 0x30, 0x35, 0x35, 0x30, 0x33, 0x31,
 111     0x33, 0x30, 0x37, 0x31, 0x30, 0x32, 0x36, 0x5a, 0x30, 0x3e, 0x31, 0x28,
 112     0x30, 0x26, 0x06, 0x03, 0x55, 0x04, 0x0b, 0x13, 0x1f, 0x53, 0x65, 0x63,
 113     0x75, 0x72, 0x69, 0x74, 0x79, 0x54, 0x65, 0x73, 0x74, 0x73, 0x20, 0x53,
 114     0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x43, 0x65, 0x72, 0x74, 0x20, 0x28,
 115     0x52, 0x53, 0x41, 0x29, 0x31, 0x12, 0x30, 0x10, 0x06, 0x03, 0x55, 0x04,
 116     0x03, 0x13, 0x09, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x68, 0x6f, 0x73, 0x74,
 117     0x30, 0x81, 0x9f, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
 118     0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x81, 0x8d, 0x00, 0x30, 0x81,
 119     0x89, 0x02, 0x81, 0x81, 0x00, 0xab, 0x05, 0xba, 0xdc, 0x2d, 0xb3, 0x03,
 120     0xf1, 0x6c, 0x60, 0x7f, 0x5e, 0x80, 0x85, 0x54, 0x24, 0xc7, 0x87, 0x6e,
 121     0xe5, 0xf1, 0xae, 0x76, 0x59, 0xe3, 0x4b, 0x9c, 0xff, 0xa2, 0x41, 0xfc,
 122     0x40, 0xf8, 0xa8, 0x33, 0x12, 0xa9, 0x1b, 0x1a, 0xc5, 0xe8, 0xef, 0xb1,
 123     0xe3, 0x75, 0x0b, 0xd2, 0x28, 0x49, 0x48, 0x64, 0x9c, 0x3d, 0x89, 0xb6,
 124     0xf8, 0xa5, 0x93, 0xd0, 0x29, 0x8c, 0x9e, 0x7a, 0xf6, 0x00, 0x20, 0x08,
 125     0x52, 0x08, 0xdc, 0x1d, 0x17, 0x8b, 0x44, 0x4e, 0x32, 0x13, 0xdc, 0xb1,
 126     0x50, 0xa5, 0xf0, 0x94, 0x25, 0x50, 0xfa, 0x1e, 0xe3, 0xae, 0x66, 0x19,
 127     0x13, 0x3e, 0x20, 0x86, 0x05, 0x9c, 0xda, 0xd9, 0xff, 0x8f, 0x72, 0x6e,
 128     0xf5, 0xc1, 0xfd, 0x86, 0xae, 0x26, 0xcc, 0x4b, 0xc8, 0x9f, 0xa9, 0xd6,
 129     0x3a, 0x1f, 0xb6, 0x8a, 0x8f, 0x04, 0x2d, 0xbb, 0xa4, 0x47, 0xb3, 0xfb,
 130     0xf9, 0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x0d, 0x30, 0x0b, 0x30, 0x09,
 131     0x06, 0x03, 0x55, 0x1d, 0x13, 0x04, 0x02, 0x30, 0x00, 0x30, 0x0d, 0x06,
 132     0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05, 0x05, 0x00,
 133     0x03, 0x82, 0x01, 0x01, 0x00, 0xa7, 0x35, 0x63, 0xc8, 0x0a, 0xf7, 0xae,
 134     0x0f, 0xe8, 0x10, 0x50, 0xb0, 0x79, 0x04, 0xa5, 0xf3, 0x48, 0x5d, 0x0a,
 135     0x7a, 0x6b, 0xd0, 0xef, 0x17, 0x43, 0xe5, 0x21, 0xd4, 0xbb, 0xef, 0xac,
 136     0x04, 0x21, 0x50, 0x7d, 0xd8, 0xe8, 0xf1, 0x3f, 0xd1, 0xb7, 0xa5, 0x93,
 137     0xb4, 0xa8, 0xec, 0x23, 0xbe, 0xb6, 0xd9, 0xcc, 0xbe, 0x3c, 0x81, 0x34,
 138     0x25, 0x24, 0x81, 0x1e, 0xd9, 0x8c, 0xd6, 0x20, 0x14, 0x36, 0x83, 0x29,
 139     0x7f, 0x56, 0xcd, 0xc3, 0x90, 0xd0, 0x2d, 0x54, 0x8b, 0x05, 0xcb, 0xab,
 140     0xb1, 0xf2, 0x44, 0xfc, 0xba, 0x73, 0xbf, 0x97, 0xc2, 0x2b, 0x5a, 0x6a,
 141     0x49, 0x27, 0x29, 0x7c, 0xb7, 0xb1, 0x4a, 0x1f, 0x28, 0x41, 0x05, 0x63,
 142     0x58, 0x8e, 0xd5, 0x7e, 0x46, 0x74, 0x11, 0x01, 0x72, 0x93, 0x1f, 0xea,
 143     0xf7, 0x37, 0x4a, 0xfa, 0x84, 0x53, 0xb6, 0x3c, 0x0e, 0xde, 0xe5, 0x1c,
 144     0x12, 0x86, 0x0a, 0xf6, 0x8b, 0xac, 0xc8, 0xb5, 0x9a, 0x9b, 0xd2, 0x28,
 145     0x15, 0x18, 0x83, 0x0a, 0xfc, 0x47, 0x1a, 0xcf, 0xed, 0xa1, 0x95, 0x4e,
 146     0xcc, 0x3c, 0x2a, 0x9a, 0xdf, 0x09, 0xec, 0x28, 0x20, 0xfd, 0xc5, 0x42,
 147     0xf1, 0xd8, 0x2f, 0x21, 0x88, 0xec, 0xe2, 0x24, 0xb2, 0xe2, 0x45, 0x5a,
 148     0xce, 0xb4, 0x78, 0xb3, 0x30, 0x38, 0x0e, 0x1c, 0x6a, 0xa3, 0x04, 0x0e,
 149     0xac, 0xa4, 0x97, 0xe3, 0xc1, 0x46, 0x0a, 0x9d, 0x65, 0x9a, 0xe9, 0x02,
 150     0x12, 0xf0, 0x88, 0x58, 0xc6, 0xde, 0xe5, 0x23, 0x42, 0x3c, 0x58, 0x52,
 151     0x27, 0x1a, 0xe2, 0xf5, 0x4a, 0x21, 0x47, 0xb2, 0x13, 0x0c, 0xb2, 0xd0,
 152     0xcc, 0xb3, 0xfd, 0x66, 0x2a, 0xa6, 0x38, 0x5b, 0xe6, 0x2e, 0x90, 0x9e,
 153     0x62, 0x3f, 0x7e, 0x60, 0xee, 0xd4, 0x02, 0x58, 0x7d, 0x5c, 0xf8, 0x39,
 154     0x27, 0xa9, 0xdb, 0x3e, 0x24, 0x3c, 0xc0, 0xde, 0xc8
 155 };
 156
 157
 158 #define SERVER "127.0.0.1"
 159 //#define SERVER "17.201.58.114"
 160 #define PORT 23232
 161 #define BUFLEN 128
 162 #define COUNT 10
 163
 164 #if 0
 165 static void dumppacket(const unsigned char *data, unsigned long len)
 166 {
 167     unsigned long i;
 168     for(i=0;i<len;i++)
 169     {
 170         if((i&0xf)==0) printf("%04lx :",i);
 171         printf(" %02x", data[i]);
 172         if((i&0xf)==0xf) printf("\n");
 173     }
 174     printf("\n");
 175 }
 176 #endif
 177
 178 /* 2K should be enough for everybody */
 179 #define MTU 2048
 180 static unsigned char readBuffer[MTU];
 181 static unsigned int  readOff=0;
 182 static size_t        readLeft=0;
 183
 184 static
 185 OSStatus SocketRead(
 186                     SSLConnectionRef    connection,
 187                     void                                *data,
 188                     size_t                              *dataLength)
 189 {
 190     int fd = (int)connection;
 191     ssize_t len;
 192     uint8_t *d=readBuffer;
 193
 194     if(readLeft==0)
 195     {
 196         len = read(fd, readBuffer, MTU);
 197
 198         if(len>0) {
 199             readOff=0;
 200             readLeft=(size_t) len;
 201             printf("SocketRead: %ld bytes... epoch: %02x seq=%02x%02x\n",
 202                    len, d[4], d[9], d[10]);
 203
 204         } else {
 205             int theErr = errno;
 206             switch(theErr) {
 207                 case EAGAIN:
 208                     //printf("SocketRead: EAGAIN\n");
 209                     *dataLength=0;
 210                     /* nonblocking, no data */
 211                     return errSSLWouldBlock;
 212                 default:
 213                     perror("SocketRead");
 214                     return errSecIO;
 215             }
 216         }
 217     }
 218
 219     if(readLeft<*dataLength) {
 220         *dataLength=readLeft;
 221     }
 222
 223     memcpy(data, readBuffer+readOff, *dataLength);
 224     readLeft-=*dataLength;
 225     readOff+=*dataLength;
 226
 227     return errSecSuccess;
 228
 229 }
 230
 231 static
 232 OSStatus SocketWrite(
 233                      SSLConnectionRef   connection,
 234                      const void         *data,
 235                      size_t                     *dataLength)    /* IN/OUT */
 236 {
 237     int fd = (int)connection;
 238     ssize_t len;
 239     OSStatus err = errSecSuccess;
 240     const uint8_t *d=data;
 241
 242 #if 0
 243     if((rand()&3)==1) {
 244
 245         /* drop 1/8th packets */
 246         printf("SocketWrite: Drop %ld bytes... epoch: %02x seq=%02x%02x\n",
 247                *dataLength, d[4], d[9], d[10]);
 248         return errSecSuccess;
 249
 250     }
 251 #endif
 252
 253     len = send(fd, data, *dataLength, 0);
 254
 255     if(len>0) {
 256         *dataLength=(size_t)len;
 257         printf("SocketWrite: Sent %ld bytes... epoch: %02x seq=%02x%02x\n",
 258                len, d[4], d[9], d[10]);
 259         return err;
 260     }
 261
 262     int theErr = errno;
 263     switch(theErr) {
 264         case EAGAIN:
 265             /* nonblocking, no data */
 266             err = errSSLWouldBlock;
 267             break;
 268         default:
 269             perror("SocketWrite");
 270             err = errSecIO;
 271             break;
 272     }
 273
 274     return err;
 275
 276 }
 277
 278
 279 int main(int argc, char **argv)
 280 {
 281     int fd;
 282     struct sockaddr_in sa;
 283
 284     if ((fd=socket(AF_INET, SOCK_DGRAM, 0))==-1) {
 285         perror("socket");
 286         exit(-1);
 287     }
 288
 289 #ifdef NO_SERVER
 290 # if DEBUG
 291     securityd_init();
 292 # endif
 293 #endif
 294
 295     memset((char *) &sa, 0, sizeof(sa));
 296     sa.sin_family = AF_INET;
 297     sa.sin_port = htons(PORT);
 298     if (inet_aton(SERVER, &sa.sin_addr)==0) {
 299         fprintf(stderr, "inet_aton() failed\n");
 300         exit(1);
 301     }
 302
 303     time_t seed=time(NULL);
 304 //    time_t seed=1298952499;
 305     srand((unsigned)seed);
 306     printf("Random drop initialized with seed = %lu\n", seed);
 307
 308     if(connect(fd, (struct sockaddr *)&sa, sizeof(sa))==-1)
 309     {
 310         perror("connect");
 311         return errno;
 312     }
 313
 314     /* Change to non blocking io */
 315     fcntl(fd, F_SETFL, O_NONBLOCK);
 316
 317     SSLConnectionRef c=(SSLConnectionRef)(intptr_t)fd;
 318
 319
 320     OSStatus            ortn;
 321     SSLContextRef       ctx = NULL;
 322
 323     SSLClientCertificateState certState;
 324     SSLCipherSuite negCipher;
 325     SSLProtocol negVersion;
 326
 327         /*
 328          * Set up a SecureTransport session.
 329          */
 330         ortn = SSLNewDatagramContext(false, &ctx);
 331         if(ortn) {
 332                 printSslErrStr("SSLNewDatagramContext", ortn);
 333                 return ortn;
 334         }
 335         ortn = SSLSetIOFuncs(ctx, SocketRead, SocketWrite);
 336         if(ortn) {
 337                 printSslErrStr("SSLSetIOFuncs", ortn);
 338                 return ortn;
 339         }
 340
 341     ortn = SSLSetConnection(ctx, c);
 342         if(ortn) {
 343                 printSslErrStr("SSLSetConnection", ortn);
 344                 return ortn;
 345         }
 346
 347     ortn = SSLSetMaxDatagramRecordSize(ctx, 400);
 348     if(ortn) {
 349                 printSslErrStr("SSLSetMaxDatagramRecordSize", ortn);
 350         return ortn;
 351         }
 352
 353     /* Lets not verify the cert, which is a random test cert */
 354     ortn = SSLSetEnableCertVerify(ctx, false);
 355     if(ortn) {
 356         printSslErrStr("SSLSetEnableCertVerify", ortn);
 357         return ortn;
 358     }
 359
 360     ortn = SSLSetCertificate(ctx, chain_from_der(false, ServerRSA_Key_der, sizeof(ServerRSA_Key_der),
 361                                                  ServerRSA_Cert_CA_RSA_der, sizeof(ServerRSA_Cert_CA_RSA_der)));
 362     if(ortn) {
 363         printSslErrStr("SSLSetCertificate", ortn);
 364         return ortn;
 365     }
 366
 367     do {
 368                 ortn = SSLHandshake(ctx);
 369             if(ortn == errSSLWouldBlock) {
 370                 /* keep UI responsive */
 371                 sslOutputDot();
 372             }
 373     } while (ortn == errSSLWouldBlock);
 374
 375
 376     SSLGetClientCertificateState(ctx, &certState);
 377         SSLGetNegotiatedCipher(ctx, &negCipher);
 378         SSLGetNegotiatedProtocolVersion(ctx, &negVersion);
 379
 380     int count;
 381     size_t len, readLen, writeLen;
 382     char buffer[BUFLEN];
 383
 384     count = 0;
 385     while(count<COUNT) {
 386         int timeout = 10000;
 387
 388         snprintf(buffer, BUFLEN, "Message %d", count);
 389         len = strlen(buffer);
 390
 391         ortn=SSLWrite(ctx, buffer, len, &writeLen);
 392         if(ortn) {
 393             printSslErrStr("SSLWrite", ortn);
 394             break;
 395         }
 396         printf("Wrote %lu bytes\n", writeLen);
 397
 398         count++;
 399
 400         do {
 401             ortn=SSLRead(ctx, buffer, BUFLEN, &readLen);
 402         } while((ortn==errSSLWouldBlock) && (timeout--));
 403         if(ortn==errSSLWouldBlock) {
 404             printf("Echo timeout...\n");
 405             continue;
 406         }
 407         if(ortn) {
 408                 printSslErrStr("SSLRead", ortn);
 409                 break;
 410         }
 411         buffer[readLen]=0;
 412         printf("Received %lu bytes: %s\n", readLen, buffer);
 413
 414      }
 415
 416     SSLClose(ctx);
 417
 418     SSLDisposeContext(ctx);
 419
 420     return ortn;
 421 }