Skip to content

Commit 6c5b5f4

Browse files
douzzerdouzzer
authored
Merge pull request #448 from SparkiDev/dtls_read_write_threaded
DTLS threaded read-write with same SSL object
2 parents 00fbf9c + 3bb9656 commit 6c5b5f4

3 files changed

Lines changed: 678 additions & 0 deletions

File tree

‎.gitignore‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -51,13 +51,15 @@ android/wolfssljni-ndk-sample/proguard-project.txt
5151
/dtls/client-dtls-ipv6
5252
/dtls/client-dtls-nonblocking
5353
/dtls/client-dtls-resume
54+
/dtls/client-dtls-rw-threads
5455
/dtls/client-dtls-shared
5556
/dtls/client-dtls
5657
/dtls/client-dtls13
5758
/dtls/client-udp
5859
/dtls/server-dtls-callback
5960
/dtls/server-dtls-ipv6
6061
/dtls/server-dtls-nonblocking
62+
/dtls/server-dtls-rw-threads
6163
/dtls/server-dtls-threaded
6264
/dtls/server-dtls
6365
/dtls/server-dtls13

‎dtls/client-dtls-rw-threads.c‎

Lines changed: 255 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,255 @@
1+
/*
2+
* client-dtls.c
3+
*
4+
* Copyright (C) 2006-2020 wolfSSL Inc.
5+
*
6+
* This file is part of wolfSSL. (formerly known as CyaSSL)
7+
*
8+
* wolfSSL is free software; you can redistribute it and/or modify
9+
* it under the terms of the GNU General Public License as published by
10+
* the Free Software Foundation; either version 2 of the License, or
11+
* (at your option) any later version.
12+
*
13+
* wolfSSL is distributed in the hope that it will be useful,
14+
* but WITHOUT ANY WARRANTY; without even the implied warranty of
15+
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16+
* GNU General Public License for more details.
17+
*
18+
* You should have received a copy of the GNU General Public License
19+
* along with this program; if not, write to the Free Software
20+
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
21+
*
22+
*=============================================================================
23+
*
24+
* Bare-bones example of a DTLS client for instructional/learning purposes.
25+
*/
26+
27+
#include <wolfssl/options.h>
28+
#include <unistd.h>
29+
#include <wolfssl/ssl.h>
30+
#include <netdb.h>
31+
#include <signal.h>
32+
#include <sys/socket.h>
33+
#include <arpa/inet.h>
34+
#include <netinet/in.h>
35+
#include <stdio.h>
36+
#include <stdlib.h>
37+
#include <string.h>
38+
#include <pthread.h>
39+
40+
#include <sys/time.h>
41+
42+
/* WARNING: This function is not portable. */
43+
static WC_INLINE double current_time(int reset)
44+
{
45+
struct timeval tv;
46+
gettimeofday(&tv, 0);
47+
(void)reset;
48+
49+
return (double)tv.tv_sec + (double)tv.tv_usec / 1000000;
50+
}
51+
52+
#define SERV_PORT 11111
53+
54+
typedef struct {
55+
int size; /* Size of buffer to read. */
56+
WOLFSSL* ssl; /* SSL object to use. */
57+
} threadArgs;
58+
59+
static int cleanup; /* To handle shutdown */
60+
static int minRunTime = 1; /* Minimum run time. Default: 1 second */
61+
62+
/* Reader thread.
63+
*
64+
* Only started after handshake complete.
65+
*/
66+
void* Reader(void* openSock)
67+
{
68+
threadArgs* args = (threadArgs*)openSock;
69+
int recvLen = 0; /* length of message */
70+
int msgLen = args->size; /* the size of message */
71+
unsigned char buff[msgLen]; /* the incoming message */
72+
WOLFSSL* ssl = args->ssl;
73+
int result;
74+
fd_set recvfds, errfds;
75+
struct timeval timeout;
76+
int currTimeout;
77+
int nb_sockfd;
78+
int nfds;
79+
80+
nb_sockfd = (int) wolfSSL_get_fd(ssl);
81+
82+
printf("Reading\n");
83+
84+
while (!cleanup) {
85+
currTimeout = wolfSSL_dtls_get_current_timeout(ssl);
86+
nfds = nb_sockfd + 1;
87+
timeout = (struct timeval) { (currTimeout > 0) ? currTimeout : 0, 0};
88+
89+
/* Setup file descriptor list to monitor. */
90+
FD_ZERO(&recvfds);
91+
FD_SET(nb_sockfd, &recvfds);
92+
FD_ZERO(&errfds);
93+
FD_SET(nb_sockfd, &errfds);
94+
95+
result = select(nfds, &recvfds, NULL, &errfds, &timeout);
96+
if ((result > 0) && FD_ISSET(nb_sockfd, &errfds)) {
97+
/* Tell other thread to cleanup. */
98+
cleanup = 1;
99+
/* Finished reading. */
100+
break;
101+
}
102+
103+
/* If data waiting on receive file descriptor, read it. */
104+
if (result > 0 && FD_ISSET(nb_sockfd, &recvfds)) {
105+
/* Read application data. */
106+
if ((recvLen = wolfSSL_read(ssl, buff, msgLen-1)) < 0) {
107+
/* Handle errors. */
108+
int readErr = wolfSSL_get_error(ssl, 0);
109+
if (readErr != SSL_ERROR_WANT_READ) {
110+
printf("SSL_read failed.\n");
111+
/* Tell other threads to cleanup. */
112+
cleanup = 1;
113+
break;
114+
}
115+
}
116+
}
117+
}
118+
119+
return NULL;
120+
}
121+
122+
void* Writer(void* openSock)
123+
{
124+
threadArgs* args = (threadArgs*)openSock;
125+
char ack[] = "I hear you fashizzle!\n";
126+
WOLFSSL* ssl = args->ssl;
127+
double start = current_time(0);
128+
129+
printf("Writing\n");
130+
131+
/* Keep writing while not in cleanup. */
132+
while (!cleanup) {
133+
/* Write message and check for error. */
134+
if (wolfSSL_write(ssl, ack, sizeof(ack)) < 0) {
135+
printf("wolfSSL_write fail.\n");
136+
/* Tell other threads to cleanup. */
137+
cleanup = 1;
138+
break;
139+
}
140+
141+
/* Stop writing after a minimum run time. */
142+
if (current_time(0) > start + minRunTime) {
143+
printf("wolfSSL_write done.\n");
144+
cleanup = 1;
145+
break;
146+
}
147+
}
148+
149+
return NULL;
150+
}
151+
152+
int main (int argc, char** argv)
153+
{
154+
/* standard variables used in a dtls client*/
155+
int n = 0;
156+
int sockfd = 0;
157+
int err1;
158+
struct sockaddr_in servAddr;
159+
WOLFSSL* ssl = 0;
160+
WOLFSSL_CTX* ctx = 0;
161+
char cert_array[] = "certs/ca-cert.pem";
162+
char* certs = cert_array;
163+
threadArgs args;
164+
pthread_t threadidReader;
165+
pthread_t threadidWriter;
166+
167+
/* Program argument checking */
168+
if (argc < 2 || argc > 3) {
169+
printf("usage: udpcli <IP address> [<min time>]\n");
170+
return 1;
171+
}
172+
173+
if (argc == 3) {
174+
minRunTime = atoi(argv[2]);
175+
}
176+
177+
/* Initialize wolfSSL before assigning ctx */
178+
wolfSSL_Init();
179+
wolfSSL_Debugging_ON();
180+
181+
/* wolfSSL_Debugging_ON(); */
182+
183+
if ( (ctx = wolfSSL_CTX_new(wolfDTLSv1_2_client_method())) == NULL) {
184+
fprintf(stderr, "wolfSSL_CTX_new error.\n");
185+
return 1;
186+
}
187+
188+
/* Load certificates into ctx variable */
189+
if (wolfSSL_CTX_load_verify_locations(ctx, certs, 0)
190+
!= SSL_SUCCESS) {
191+
fprintf(stderr, "Error loading %s, please check the file.\n", certs);
192+
return 1;
193+
}
194+
195+
/* Assign ssl variable */
196+
ssl = wolfSSL_new(ctx);
197+
if (ssl == NULL) {
198+
printf("unable to get ssl object");
199+
return 1;
200+
}
201+
202+
/* servAddr setup */
203+
memset(&servAddr, 0, sizeof(servAddr));
204+
servAddr.sin_family = AF_INET;
205+
servAddr.sin_port = htons(SERV_PORT);
206+
if (inet_pton(AF_INET, argv[1], &servAddr.sin_addr) < 1) {
207+
printf("Error and/or invalid IP address\n");
208+
return 1;
209+
}
210+
211+
wolfSSL_dtls_set_peer(ssl, &servAddr, sizeof(servAddr));
212+
213+
if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
214+
printf("cannot create a socket.\n");
215+
return 1;
216+
}
217+
218+
/* Set the file descriptor for ssl and connect with ssl variable */
219+
wolfSSL_set_fd(ssl, sockfd);
220+
wolfSSL_dtls_set_using_nonblock(ssl, 1);
221+
fcntl(sockfd, F_SETFL, O_NONBLOCK);
222+
223+
while (wolfSSL_connect(ssl) != SSL_SUCCESS) {
224+
err1 = wolfSSL_get_error(ssl, 0);
225+
if (err1 != SSL_ERROR_WANT_READ && err1 != SSL_ERROR_WANT_WRITE) {
226+
printf("err = %d, %s\n", err1,
227+
wolfSSL_ERR_reason_error_string(err1));
228+
printf("SSL_connect failed\n");
229+
return 1;
230+
}
231+
}
232+
233+
cleanup = 0;
234+
args.size = 256;
235+
args.ssl = ssl;
236+
237+
fcntl(wolfSSL_get_fd(ssl), F_SETFL, O_NONBLOCK);
238+
239+
/* Create reader and writer threads. */
240+
pthread_create(&threadidReader, NULL, Reader, &args);
241+
pthread_create(&threadidWriter, NULL, Writer, &args);
242+
243+
/* Wait for read/write threads to be done. */
244+
pthread_join(threadidReader, NULL);
245+
pthread_join(threadidWriter, NULL);
246+
247+
/* Housekeeping */
248+
wolfSSL_shutdown(ssl);
249+
wolfSSL_free(ssl);
250+
close(sockfd);
251+
wolfSSL_CTX_free(ctx);
252+
wolfSSL_Cleanup();
253+
254+
return 0;
255+
}

0 commit comments

Comments
 (0)