blob: 56be087c9332788314bf9159fe2260a044c0d2e6 [file] [log] [blame]
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +02001/*
2 * Hello world example of a TLS client: fetch an HTTPS page
3 *
4 * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
5 *
6 * This file is part of mbed TLS (https://tls.mbed.org)
Manuel Pégourié-Gonnardcdee2d92015-08-07 09:40:51 +02007 *
8 * This program 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 * This program 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 along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +020021 */
22
23#if !defined(TARGET_LIKE_MBED)
24
25#include <stdio.h>
26
27int main() {
28 printf("this program only works on mbed OS\n");
29 return 0;
30}
31
32#else
33
34/** \file main.cpp
35 * \brief An example TLS Client application
36 * This application sends an HTTPS request to developer.mbed.org and searches for a string in
37 * the result.
38 *
39 * This example is implemented as a logic class (HelloHTTPS) wrapping a TCP socket.
40 * The logic class handles all events, leaving the main loop to just check if the process
41 * has finished.
42 */
43
44/* Change to a number between 1 and 4 to debug the TLS connection */
45#define DEBUG_LEVEL 0
46
47/* Change to 1 to skip certificate verification (UNSAFE, for debug only!) */
48#define UNSAFE 0
49
50#include "mbed.h"
Manuel Pégourié-Gonnarde87b04c2015-08-11 04:09:44 +020051#include "sal-iface-eth/EthernetInterface.h"
Manuel Pégourié-Gonnardae5398a2015-08-04 14:10:28 +020052#include "mbed-net-sockets/TCPStream.h"
53#include "minar/minar.h"
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +020054
55#include "mbedtls/ssl.h"
56#include "mbedtls/entropy.h"
57#include "mbedtls/ctr_drbg.h"
58#include "mbedtls/error.h"
59#if DEBUG_LEVEL > 0
60#include "mbedtls/debug.h"
61#endif
62
63#include "lwipv4_init.h"
64
65namespace {
Manuel Pégourié-Gonnard42618b82015-08-17 14:19:38 +020066const char *HTTPS_SERVER_NAME = "developer.mbed.org";
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +020067const int HTTPS_SERVER_PORT = 443;
68const int RECV_BUFFER_SIZE = 600;
69
Manuel Pégourié-Gonnard42618b82015-08-17 14:19:38 +020070const char HTTPS_PATH[] = "/media/uploads/mbed_official/hello.txt";
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +020071const size_t HTTPS_PATH_LEN = sizeof(HTTPS_PATH) - 1;
72
73/* Test related data */
74const char *HTTPS_OK_STR = "200 OK";
75const char *HTTPS_HELLO_STR = "Hello world!";
76
77/* personalization string for the drbg */
78const char *DRBG_PERS = "mbed TLS helloword client";
79
80/* List of trusted root CA certificates
81 * currently just Verisign since it's the root used by developer.mbed.org
82 * If you want to trust more that one root, just concatenate them.
83 */
84const char SSL_CA_PEM[] =
85"-----BEGIN CERTIFICATE-----\n"
86"MIIDdTCCAl2gAwIBAgILBAAAAAABFUtaw5QwDQYJKoZIhvcNAQEFBQAwVzELMAkG\n"
87"A1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2ExEDAOBgNVBAsTB1Jv\n"
88"b3QgQ0ExGzAZBgNVBAMTEkdsb2JhbFNpZ24gUm9vdCBDQTAeFw05ODA5MDExMjAw\n"
89"MDBaFw0yODAxMjgxMjAwMDBaMFcxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9i\n"
90"YWxTaWduIG52LXNhMRAwDgYDVQQLEwdSb290IENBMRswGQYDVQQDExJHbG9iYWxT\n"
91"aWduIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDaDuaZ\n"
92"jc6j40+Kfvvxi4Mla+pIH/EqsLmVEQS98GPR4mdmzxzdzxtIK+6NiY6arymAZavp\n"
93"xy0Sy6scTHAHoT0KMM0VjU/43dSMUBUc71DuxC73/OlS8pF94G3VNTCOXkNz8kHp\n"
94"1Wrjsok6Vjk4bwY8iGlbKk3Fp1S4bInMm/k8yuX9ifUSPJJ4ltbcdG6TRGHRjcdG\n"
95"snUOhugZitVtbNV4FpWi6cgKOOvyJBNPc1STE4U6G7weNLWLBYy5d4ux2x8gkasJ\n"
96"U26Qzns3dLlwR5EiUWMWea6xrkEmCMgZK9FGqkjWZCrXgzT/LCrBbBlDSgeF59N8\n"
97"9iFo7+ryUp9/k5DPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8E\n"
98"BTADAQH/MB0GA1UdDgQWBBRge2YaRQ2XyolQL30EzTSo//z9SzANBgkqhkiG9w0B\n"
99"AQUFAAOCAQEA1nPnfE920I2/7LqivjTFKDK1fPxsnCwrvQmeU79rXqoRSLblCKOz\n"
100"yj1hTdNGCbM+w6DjY1Ub8rrvrTnhQ7k4o+YviiY776BQVvnGCv04zcQLcFGUl5gE\n"
101"38NflNUVyRRBnMRddWQVDf9VMOyGj/8N7yy5Y0b2qvzfvGn9LhJIZJrglfCm7ymP\n"
102"AbEVtQwdpf5pLGkkeB6zpxxxYu7KyJesF12KwvhHhm4qxFYxldBniYUr+WymXUad\n"
103"DKqC5JlR3XC321Y9YeRq4VzW9v493kHMB65jUr9TU/Qr6cf9tveCX4XSQRjbgbME\n"
104"HMUfpIBvFSDJ3gyICh3WZlXi/EjJKSZp4A==\n"
105"-----END CERTIFICATE-----\n";
106}
107
Manuel Pégourié-Gonnardae5398a2015-08-04 14:10:28 +0200108using namespace mbed::Sockets::v0;
109
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200110/**
111 * \brief HelloHTTPS implements the logic for fetching a file from a webserver
112 * using a TCP socket and parsing the result.
113 */
114class HelloHTTPS {
115public:
116 /**
117 * HelloHTTPS Constructor
118 * Initializes the TCP socket, sets up event handlers and flags.
119 *
120 * Note that CThunk is used for event handlers. This will be changed to a C++
121 * function pointer in an upcoming release.
122 *
123 *
124 * @param[in] domain The domain name to fetch from
125 * @param[in] port The port of the HTTPS server
126 */
127 HelloHTTPS(const char * domain, const uint16_t port) :
128 _stream(SOCKET_STACK_LWIP_IPV4), _domain(domain), _port(port)
129 {
130
131 _error = false;
132 _gothello = false;
133 _got200 = false;
134 _bpos = 0;
135 _request_sent = 0;
136 _stream.open(SOCKET_AF_INET4);
137
138 mbedtls_entropy_init(&_entropy);
139 mbedtls_ctr_drbg_init(&_ctr_drbg);
140 mbedtls_x509_crt_init(&_cacert);
141 mbedtls_ssl_init(&_ssl);
142 mbedtls_ssl_config_init(&_ssl_conf);
143 }
144 /**
145 * Initiate the test.
146 *
147 * Starts by clearing test flags, then resolves the address with DNS.
148 *
149 * @param[in] path The path of the file to fetch from the HTTPS server
150 * @return SOCKET_ERROR_NONE on success, or an error code on failure
151 */
Manuel Pégourié-Gonnard8356fc22015-08-07 14:35:12 +0200152 void startTest(const char *path) {
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200153 /* Initialize the flags */
154 _got200 = false;
155 _gothello = false;
156 _error = false;
157 _disconnected = false;
158 _request_sent = false;
159 /* Fill the request buffer */
160 _bpos = snprintf(_buffer, sizeof(_buffer) - 1, "GET %s HTTP/1.1\nHost: %s\n\n", path, HTTPS_SERVER_NAME);
161
162 /*
163 * Initialize TLS-related stuf.
164 */
165 int ret;
166 if ((ret = mbedtls_ctr_drbg_seed(&_ctr_drbg, mbedtls_entropy_func, &_entropy,
167 (const unsigned char *) DRBG_PERS,
168 sizeof (DRBG_PERS))) != 0) {
169 print_mbedtls_error("mbedtls_crt_drbg_init", ret);
Manuel Pégourié-Gonnard8356fc22015-08-07 14:35:12 +0200170 _error = true;
171 return;
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200172 }
173
174 if ((ret = mbedtls_x509_crt_parse(&_cacert, (const unsigned char *) SSL_CA_PEM,
175 sizeof (SSL_CA_PEM))) != 0) {
176 print_mbedtls_error("mbedtls_x509_crt_parse", ret);
Manuel Pégourié-Gonnard8356fc22015-08-07 14:35:12 +0200177 _error = true;
178 return;
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200179 }
180
181 if ((ret = mbedtls_ssl_config_defaults(&_ssl_conf,
182 MBEDTLS_SSL_IS_CLIENT,
183 MBEDTLS_SSL_TRANSPORT_STREAM,
184 MBEDTLS_SSL_PRESET_DEFAULT)) != 0) {
185 print_mbedtls_error("mbedtls_ssl_config_defaults", ret);
Manuel Pégourié-Gonnard8356fc22015-08-07 14:35:12 +0200186 _error = true;
187 return;
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200188 }
189
190 mbedtls_ssl_conf_ca_chain(&_ssl_conf, &_cacert, NULL);
191 mbedtls_ssl_conf_rng(&_ssl_conf, mbedtls_ctr_drbg_random, &_ctr_drbg);
192
193#if UNSAFE
194 mbedtls_ssl_conf_authmode(&_ssl_conf, MBEDTLS_SSL_VERIFY_OPTIONAL);
195#endif
196
197#if DEBUG_LEVEL > 0
198 mbedtls_ssl_conf_verify(&_ssl_conf, my_verify, NULL);
199 mbedtls_ssl_conf_dbg(&_ssl_conf, my_debug, NULL);
200 mbedtls_debug_set_threshold(DEBUG_LEVEL);
201#endif
202
203 if ((ret = mbedtls_ssl_setup(&_ssl, &_ssl_conf)) != 0) {
204 print_mbedtls_error("mbedtls_ssl_setup", ret);
Manuel Pégourié-Gonnard8356fc22015-08-07 14:35:12 +0200205 _error = true;
206 return;
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200207 }
208
209 mbedtls_ssl_set_hostname(&_ssl, HTTPS_SERVER_NAME);
210
211 mbedtls_ssl_set_bio(&_ssl, static_cast<void *>(&_stream),
212 ssl_send, ssl_recv, NULL );
213
214
215 /* Connect to the server */
216 printf("Connecting to %s:%d\r\n", _domain, _port);
217 /* Resolve the domain name: */
Manuel Pégourié-Gonnardae5398a2015-08-04 14:10:28 +0200218 socket_error_t err = _stream.resolve(_domain, TCPStream::DNSHandler_t(this, &HelloHTTPS::onDNS));
Manuel Pégourié-Gonnard8356fc22015-08-07 14:35:12 +0200219 if(err != SOCKET_ERROR_NONE)
220 _error = true;
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200221 }
222 /**
223 * Check if the test has completed.
224 * @return Returns true if done, false otherwise.
225 */
226 bool done() {
227 return _error || (_got200 && _gothello);
228 }
229 /**
230 * Check if there was an error
231 * @return Returns true if there was an error, false otherwise.
232 */
233 bool error() {
234 return _error;
235 }
236 /**
237 * Closes the TCP socket
238 */
239 void close() {
240 _stream.close();
241 while (!_disconnected)
242 __WFI();
243 }
244protected:
245 /**
246 * Helper for pretty-printing mbed TLS error codes
247 */
248 static void print_mbedtls_error(const char *name, int err) {
249 char buf[128];
250 mbedtls_strerror(err, buf, sizeof (buf));
251 printf("%s() failed: -0x%04x (%d): %s\r\n", name, -err, err, buf);
252 }
253
254#if DEBUG_LEVEL > 0
255 /**
256 * Debug callback for mbed TLS
257 * Just prints on the USB serial port
258 */
259 static void my_debug(void *ctx, int level, const char *str)
260 {
261 (void) ctx;
262 (void) level;
263
264 printf("%s", str);
265 }
266
267 /**
268 * Certificate verification callback for mbed TLS
269 * Here we only use it to display information on each cert in the chain
270 */
271 static int my_verify(void *data, mbedtls_x509_crt *crt, int depth, int *flags)
272 {
273 char buf[1024];
274 (void) data;
275
276 printf("\nVerifying certificate at depth %d:\n", depth);
277 mbedtls_x509_crt_info(buf, sizeof (buf) - 1, " ", crt);
278 printf("%s", buf);
279
280 if (*flags == 0)
281 printf("No verification issue for this certificate\n");
282 else
283 {
284 mbedtls_x509_crt_verify_info(buf, sizeof (buf), " ! ", *flags);
285 printf("%s\n", buf);
286 }
287
288 return 0;
289 }
290#endif
291
292 /**
293 * Receive callback for mbed TLS
294 */
295 static int ssl_recv(void *ctx, unsigned char *buf, size_t len) {
Manuel Pégourié-Gonnardae5398a2015-08-04 14:10:28 +0200296 TCPStream *stream = static_cast<TCPStream *>(ctx);
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200297 socket_error_t err = stream->recv(buf, &len);
298
299 if (err == SOCKET_ERROR_NONE) {
300 return static_cast<int>(len);
301 } else if (err == SOCKET_ERROR_WOULD_BLOCK) {
302 return MBEDTLS_ERR_SSL_WANT_READ;
303 } else {
304 return -1;
305 }
306 }
307
308 /**
309 * Send callback for mbed TLS
310 */
311 static int ssl_send(void *ctx, const unsigned char *buf, size_t len) {
Manuel Pégourié-Gonnardae5398a2015-08-04 14:10:28 +0200312 TCPStream *stream = static_cast<TCPStream *>(ctx);
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200313
314 socket_error_t err = stream->send(buf, len);
315
316 if (err == SOCKET_ERROR_NONE) {
317 return static_cast<int>(len);
318 } else if (err == SOCKET_ERROR_WOULD_BLOCK) {
319 return MBEDTLS_ERR_SSL_WANT_WRITE;
320 } else {
321 return -1;
322 }
323 }
324
Manuel Pégourié-Gonnardae5398a2015-08-04 14:10:28 +0200325 void onError(Socket *s, socket_error_t err) {
326 (void) s;
327 printf("MBED: Socket Error: %s (%d)\r\n", socket_strerror(err), err);
328 _stream.close();
329 _error = true;
330 minar::Scheduler::stop();
331 }
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200332 /**
333 * On Connect handler
Manuel Pégourié-Gonnardae5398a2015-08-04 14:10:28 +0200334 * Starts the TLS handshake
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200335 */
Manuel Pégourié-Gonnardae5398a2015-08-04 14:10:28 +0200336 void onConnect(TCPStream *s) {
337 s->setOnReadable(TCPStream::ReadableHandler_t(this, &HelloHTTPS::onReceive));
338 s->setOnDisconnect(TCPStream::DisconnectHandler_t(this, &HelloHTTPS::onDisconnect));
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200339
340 /* Start the handshake, the rest will be done in onReceive() */
341 int ret = mbedtls_ssl_handshake(&_ssl);
342 if (ret < 0) {
343 if (ret != MBEDTLS_ERR_SSL_WANT_READ &&
344 ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
345 print_mbedtls_error("mbedtls_ssl_handshake", ret);
346 _error = true;
347 }
348 return;
349 }
350 }
351 /**
352 * On Receive handler
353 * Parses the response from the server, to check for the HTTPS 200 status code and the expected response ("Hello World!")
354 */
Manuel Pégourié-Gonnardae5398a2015-08-04 14:10:28 +0200355 void onReceive(Socket *s) {
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200356 if (_error)
357 return;
358
359 /* Send request if not done yet */
360 if (!_request_sent) {
361 int ret = mbedtls_ssl_write(&_ssl, (const unsigned char *) _buffer, _bpos);
362 if (ret < 0) {
363 if (ret != MBEDTLS_ERR_SSL_WANT_READ &&
364 ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
365 print_mbedtls_error("mbedtls_ssl_write", ret);
366 _error = true;
367 }
368 return;
369 }
370
371 /* If we get here, the request was sent */
372 _request_sent = 1;
373
374 /* It also means the handshake is done, time to print info */
375 printf("TLS connection to %s established\r\n", HTTPS_SERVER_NAME);
376 {
377 char buf[1024];
378 mbedtls_x509_crt_info(buf, sizeof(buf), "\r ",
379 mbedtls_ssl_get_peer_cert(&_ssl));
380 printf("Server certificate:\r\n%s\r", buf);
381
382#if defined(UNSAFE)
383 uint32_t flags = mbedtls_ssl_get_verify_result(&_ssl);
384 if( flags != 0 )
385 {
386 mbedtls_x509_crt_verify_info(buf, sizeof (buf), "\r ! ", flags);
387 printf("Certificate verification failed:\r\n%s\r\r\n", buf);
388 }
389 else
390#endif
391 printf("Certificate verification passed\r\n\r\n");
392 }
393 }
394
395 /* Read data out of the socket */
396 int ret = mbedtls_ssl_read(&_ssl, (unsigned char *) _buffer, sizeof(_buffer));
397 if (ret < 0) {
398 if (ret != MBEDTLS_ERR_SSL_WANT_READ &&
399 ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
400 print_mbedtls_error("mbedtls_ssl_read", ret);
401 _error = true;
402 }
403 return;
404 }
405 _bpos = static_cast<size_t>(ret);
406
407 _buffer[_bpos] = 0;
408
409 /* Check each of the flags */
410 _got200 = _got200 || strstr(_buffer, HTTPS_OK_STR) != NULL;
411 _gothello = _gothello || strstr(_buffer, HTTPS_HELLO_STR) != NULL;
412
413 /* Print status messages */
414 printf("HTTPS: Received %d chars from server\r\n", _bpos);
415 printf("HTTPS: Received 200 OK status ... %s\r\n", _got200 ? "[OK]" : "[FAIL]");
416 printf("HTTPS: Received '%s' status ... %s\r\n", HTTPS_HELLO_STR, _gothello ? "[OK]" : "[FAIL]");
417 printf("HTTPS: Received message:\r\n\r\n");
418 printf("%s", _buffer);
419 _error = !(_got200 && _gothello);
Manuel Pégourié-Gonnardae5398a2015-08-04 14:10:28 +0200420
421 s->close();
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200422 }
423 /**
424 * On DNS Handler
425 * Reads the address returned by DNS, then starts the connect process.
426 */
Manuel Pégourié-Gonnardae5398a2015-08-04 14:10:28 +0200427 void onDNS(Socket *s, struct socket_addr addr, const char *domain) {
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200428 /* Check that the result is a valid DNS response */
Manuel Pégourié-Gonnardae5398a2015-08-04 14:10:28 +0200429 if (socket_addr_is_any(&addr)) {
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200430 /* Could not find DNS entry */
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200431 printf("Could not find DNS entry for %s", HTTPS_SERVER_NAME);
Manuel Pégourié-Gonnardae5398a2015-08-04 14:10:28 +0200432 onError(s, SOCKET_ERROR_DNS_FAILED);
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200433 } else {
434 /* Start connecting to the remote host */
Manuel Pégourié-Gonnardae5398a2015-08-04 14:10:28 +0200435 char buf[16];
436 _remoteAddr.setAddr(&addr);
437 _remoteAddr.fmtIPv4(buf,sizeof(buf));
438 printf("%s address: %s\r\n",domain, buf);
439 socket_error_t err = _stream.connect(_remoteAddr, _port, TCPStream::ConnectHandler_t(this, &HelloHTTPS::onConnect));
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200440
441 if (err != SOCKET_ERROR_NONE) {
Manuel Pégourié-Gonnardae5398a2015-08-04 14:10:28 +0200442 onError(s, err);
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200443 }
444 }
445 }
Manuel Pégourié-Gonnardae5398a2015-08-04 14:10:28 +0200446 void onDisconnect(TCPStream *s) {
447 s->close();
448 minar::Scheduler::stop();
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200449 }
450
451protected:
Manuel Pégourié-Gonnardae5398a2015-08-04 14:10:28 +0200452 TCPStream _stream; /**< The TCP Socket */
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200453 const char *_domain; /**< The domain name of the HTTPS server */
454 const uint16_t _port; /**< The HTTPS server port */
455 char _buffer[RECV_BUFFER_SIZE]; /**< The response buffer */
456 size_t _bpos; /**< The current offset in the response buffer */
Manuel Pégourié-Gonnardae5398a2015-08-04 14:10:28 +0200457 SocketAddr _remoteAddr; /**< The remote address */
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200458 volatile bool _got200; /**< Status flag for HTTPS 200 */
459 volatile bool _gothello; /**< Status flag for finding the test string */
460 volatile bool _error; /**< Status flag for an error */
461 volatile bool _disconnected;
462 volatile bool _request_sent;
463
464 mbedtls_entropy_context _entropy;
465 mbedtls_ctr_drbg_context _ctr_drbg;
466 mbedtls_x509_crt _cacert;
467 mbedtls_ssl_context _ssl;
468 mbedtls_ssl_config _ssl_conf;
469};
470
471/**
472 * The main loop of the HTTPS Hello World test
473 */
474int example_client() {
475 EthernetInterface eth;
476 /* Initialise with DHCP, connect, and start up the stack */
477 eth.init();
478 eth.connect();
479 lwipv4_socket_init();
480
481 printf("\r\n\r\n");
482 printf("Client IP Address is %s\r\n", eth.getIPAddress());
483
484 HelloHTTPS hello(HTTPS_SERVER_NAME, HTTPS_SERVER_PORT);
Manuel Pégourié-Gonnard8356fc22015-08-07 14:35:12 +0200485 {
486 mbed::FunctionPointer1<void, const char*> fp(&hello, &HelloHTTPS::startTest);
487 minar::Scheduler::postCallback(fp.bind(HTTPS_PATH));
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200488 }
Manuel Pégourié-Gonnard8356fc22015-08-07 14:35:12 +0200489
490 minar::Scheduler::start();
491
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200492 eth.disconnect();
Manuel Pégourié-Gonnard8356fc22015-08-07 14:35:12 +0200493
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200494 return static_cast<int>(hello.error());
495}
496
497#include "mbed/test_env.h"
Manuel Pégourié-Gonnarde87b04c2015-08-11 04:09:44 +0200498#include "minar/minar.h"
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200499
Manuel Pégourié-Gonnarde87b04c2015-08-11 04:09:44 +0200500static void run() {
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200501 /* The default 9600 bps is too slow to print full TLS debug info and could
502 * cause the other party to time out. Select a higher baud rate for
503 * printf(), regardless of debug level for the sake of uniformity. */
504 Serial pc(USBTX, USBRX);
505 pc.baud(115200);
506
507 MBED_HOSTTEST_TIMEOUT(120);
508 MBED_HOSTTEST_SELECT(default);
509 MBED_HOSTTEST_DESCRIPTION(mbed TLS example HTTPS client);
510 MBED_HOSTTEST_START("MBEDTLS_EX_HTTPS_CLIENT");
511 MBED_HOSTTEST_RESULT(example_client() == 0);
512}
513
Manuel Pégourié-Gonnarde87b04c2015-08-11 04:09:44 +0200514void app_start(int, char*[]) {
515 minar::Scheduler::postCallback(FunctionPointer0<void>(run).bind());
516}
517
Manuel Pégourié-Gonnard63e7eba2015-07-28 14:17:48 +0200518#endif /* TARGET_LIKE_MBED */