WolfSSL
/
wolfssl-examples
mirror of https://github.com/wolfSSL/wolfssl-examples.git
1
0
Fork 0
Code Issues Releases Wiki Activity

add mynewt client-tls sample

pull/100/head
Naruto TAKAHASHI 2018-07-14 00:57:59 +09:00
parent ffa42a7a58
commit 13d028ce36
5 changed files with 801 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
mynewt/README.md 100644
View File

@ -0,0 +1,48 @@
Apache Mynewt examples
=============
## Overview
It provides follows mynewt packages.
- apps/wolfsslclienttlsmn
- client-tls simple example ssl/tls client application for mn_socket.
## How to setup
### delopy wolfssl source to mynewt project
Specify the path of the mynewt project and execute `mynewt/setup.sh`.
```bash
./mynewt/setup.sh　/path/to/myproject_path
```
This script will deploy wolfssl's mynewt package described in the Overview to the mynewt project.
## example setting example applications to targets
This section eplains how to set wolfssl example application to target device.
Please execute follows commands at only once.
create wolfsslclienttlsmn_sim that is simulator device for unit test of client-tls.
```
cd /path/to/myproject_path
newt target delete wolfsslclienttlsmn_sim
newt target create wolfsslclienttlsmn_sim
newt target set wolfsslclienttlsmn_sim app=apps/wolfsslclienttlsmn
newt target set wolfsslclienttlsmn_sim bsp=@apache-mynewt-core/hw/bsp/native
newt target set wolfsslclienttlsmn_sim build_profile=debug
```
## build & test
build and execute wolfsslclienttlsmn_sim
```
newt clean wolfsslclienttlsmn_sim
newt build wolfsslclienttlsmn_sim
./bin/targets/wolfsslclienttlsmn_sim/app/apps/wolfsslclienttlsmn/wolfsslclienttlsmn.elf
```

39
mynewt/apps.wolfsslclienttlsmn.pkg.yml 100644
View File

@ -0,0 +1,39 @@
# Copyright (C) 2018 wolfSSL Inc.
#
# This file is part of wolfSSL.
#
# wolfSSL is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# wolfSSL is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
#
pkg.name: "apps/wolfsslclienttlsmn"
pkg.type: app
pkg.description: "wolfSSL TLS Client Application"
pkg.author: "wolfSSL<info@wolfssl.com>"
pkg.homepage: "https://www.wolfssl.com"
pkg.keywords:
pkg.deps:
- crypto/wolfssl
- "@apache-mynewt-core/kernel/os"
- "@apache-mynewt-core/sys/console/full"
- "@apache-mynewt-core/net/ip/mn_socket"
- "@apache-mynewt-core/boot/bootutil"
- "@apache-mynewt-core/sys/shell"
- "@apache-mynewt-core/sys/config"
- "@apache-mynewt-core/sys/console/full"
- "@apache-mynewt-core/sys/id"
- "@apache-mynewt-core/sys/log/full"
- "@apache-mynewt-core/sys/stats/full"
pkg.cflags: -DWOLFSSL_APACHE_MYNEWT -Wno-error -DNO_FILESYSTEM -DWOLFSSL_IGNORE_FILE_WARN

42
mynewt/apps.wolfsslclienttlsmn.syscfg.yml 100644
View File

@ -0,0 +1,42 @@
# Copyright (C) 2018 wolfSSL Inc.
#
# This file is part of wolfSSL.
#
# wolfSSL is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# wolfSSL is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
#
# Settings this app defines.
syscfg.defs:
# Settings this app overrides.
syscfg.vals:
# Enable the shell task.
SHELL_TASK: 1
# Include names for statistics.
STATS_NAMES: 1
# Log reboot messages to a flash circular buffer.
REBOOT_LOG_FCB: 1
LOG_FCB: 1
CONFIG_FCB: 1
# Enable shell commands.
STATS_CLI: 1
LOG_CLI: 1
CONFIG_CLI: 1
ETH_0: 1

626
mynewt/client-tls-mn.c 100644
View File

@ -0,0 +1,626 @@
/* client-tls-mn.c
*
* Copyright (C) 2006-2018 wolfSSL Inc.
*
* This file is part of wolfSSL. (formerly known as CyaSSL)
*
* wolfSSL is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* wolfSSL is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "os/mynewt.h"
#include <bsp/bsp.h>
#include <hal/hal_gpio.h>
#include <hal/hal_flash.h>
#include <console/console.h>
#include <log/log.h>
#include <config/config.h>
#include <hal/hal_system.h>
#include <bootutil/image.h>
#include <bootutil/bootutil.h>
#include <shell/shell.h>
#include <mn_socket/mn_socket.h>
// #include <inet_def_service/inet_def_service.h>
#include <assert.h>
#include <string.h>
#include <id/id.h>
#if MYNEWT_VAL(BUILD_WITH_OIC)
#include <oic/oc_api.h>
#include <oic/oc_log.h>
#include <cborattr/cborattr.h>
#endif
#ifdef ARCH_sim
#include <mcu/mcu_sim.h>
#endif
/* wolfSSL */
#include <wolfssl/ssl.h>
#define USE_CERT_BUFFERS_2048
#include <wolfssl/certs_test.h>
#define DEFAULT_IPADDR "93.184.216.34" // www.example.com
#define DEFAULT_PORT 443
struct os_sem test_sem;
static struct log my_log;
#define MAX_CBMEM_BUF 2048
static uint32_t cbmem_buf[MAX_CBMEM_BUF];
static struct cbmem cbmem;
/* time command */
static int time_cli(int argc, char **argv);
struct shell_cmd time_cmd = {
.sc_cmd = "time",
.sc_cmd_func = time_cli,
};
static int
time_cli(int argc, char **argv)
{
long long time;
char *eptr;
struct os_timeval utctime;
struct os_timezone tz;
if(argc < 2) {
return 0;
}
time = strtoul(argv[1], &eptr, 0);
if (*eptr != '\0') {
console_printf("Invalid port %s\n", argv[3]);
return 0;
}
utctime.tv_sec = time;
utctime.tv_usec = 0;
tz.tz_minuteswest = 0;
tz.tz_dsttime = 0;
os_settimeofday(&utctime, &tz);
}
/* net command */
static int net_cli(int argc, char **argv);
struct shell_cmd net_test_cmd = {
.sc_cmd = "net",
.sc_cmd_func = net_cli
};
static struct mn_socket *net_test_socket;
static struct mn_socket *net_test_socket2;
static struct mn_sockaddr_in net_test_sin;
#if MYNEWT_VAL(BUILD_WITH_OIC)
static void omgr_app_init(void);
static const oc_handler_t omgr_oc_handler = {
.init = omgr_app_init,
};
#endif
static void net_test_readable(void *arg, int err)
{
console_printf("net_test_readable %x - %d\n", (int)arg, err);
}
static void net_test_writable(void *arg, int err)
{
console_printf("net_test_writable %x - %d\n", (int)arg, err);
}
static const union mn_socket_cb net_test_cbs = {
.socket.readable = net_test_readable,
.socket.writable = net_test_writable
};
static int net_test_newconn(void *arg, struct mn_socket *new)
{
console_printf("net_test_newconn %x - %x\n", (int)arg, (int)new);
mn_socket_set_cbs(new, NULL, &net_test_cbs);
net_test_socket2 = new;
return 0;
}
static const union mn_socket_cb net_listen_cbs = {
.listen.newconn = net_test_newconn,
};
static int
net_cli(int argc, char **argv)
{
int rc;
struct mn_sockaddr_in sin;
struct mn_sockaddr_in *sinp;
uint16_t port;
uint32_t addr;
char *eptr;
struct os_mbuf *m;
if (argc < 2) {
return 0;
}
if (!strcmp(argv[1], "udp")) {
rc = mn_socket(&net_test_socket, MN_PF_INET, MN_SOCK_DGRAM, 0);
console_printf("mn_socket(UDP) = %d %x\n", rc,
(int)net_test_socket);
} else if (!strcmp(argv[1], "tcp")) {
rc = mn_socket(&net_test_socket, MN_PF_INET, MN_SOCK_STREAM, 0);
console_printf("mn_socket(TCP) = %d %x\n", rc,
(int)net_test_socket);
} else if (!strcmp(argv[1], "connect") || !strcmp(argv[1], "bind")) {
char *addrStr = DEFAULT_IPADDR;
int port = DEFAULT_PORT;
if(argc > 3) {
// get ip address from argument
addrStr = argv[2];
}
if(argc > 4) {
// get port number from argument
char *eptr = NULL;
port = strtoul(argv[3], &eptr, 0);
if (*eptr != '\0') {
console_printf("Invalid port %s\n", argv[3]);
return 0;
}
}
if (mn_inet_pton(MN_AF_INET, addrStr, &addr) != 1) {
console_printf("Invalid address %s\n", argv[2]);
return 0;
}
uint8_t *ip = (uint8_t *)&addr;
console_printf("%d.%d.%d.%d/%d\n", ip[0], ip[1], ip[2], ip[3], port);
memset(&net_test_sin, 0, sizeof(net_test_sin));
net_test_sin.msin_len = sizeof(net_test_sin);
net_test_sin.msin_family = MN_AF_INET;
net_test_sin.msin_port = htons(port);
net_test_sin.msin_addr.s_addr = addr;
if (!strcmp(argv[1], "connect")) {
mn_socket_set_cbs(net_test_socket, NULL, &net_test_cbs);
rc = mn_connect(net_test_socket, (struct mn_sockaddr *)&net_test_sin);
console_printf("mn_connect() = %d\n", rc);
} else {
mn_socket_set_cbs(net_test_socket, NULL, &net_test_cbs);
rc = mn_bind(net_test_socket, (struct mn_sockaddr *)&net_test_sin);
console_printf("mn_bind() = %d\n", rc);
}
} else if (!strcmp(argv[1], "listen")) {
mn_socket_set_cbs(net_test_socket, NULL, &net_listen_cbs);
rc = mn_listen(net_test_socket, 2);
console_printf("mn_listen() = %d\n", rc);
} else if (!strcmp(argv[1], "close")) {
rc = mn_close(net_test_socket);
console_printf("mn_close() = %d\n", rc);
net_test_socket = NULL;
if (net_test_socket2) {
rc = mn_close(net_test_socket2);
console_printf("mn_close() = %d\n", rc);
net_test_socket2 = NULL;
}
} else if (!strcmp(argv[1], "send")) {
if (argc < 3) {
return 0;
}
m = os_msys_get_pkthdr(16, 0);
if (!m) {
console_printf("out of mbufs\n");
return 0;
}
rc = os_mbuf_copyinto(m, 0, argv[2], strlen(argv[2]));
if (rc < 0) {
console_printf("can't copy data\n");
os_mbuf_free_chain(m);
return 0;
}
if (argc > 4) {
if (mn_inet_pton(MN_AF_INET, argv[3], &addr) != 1) {
console_printf("Invalid address %s\n", argv[2]);
return 0;
}
port = strtoul(argv[4], &eptr, 0);
if (*eptr != '\0') {
console_printf("Invalid port %s\n", argv[3]);
return 0;
}
uint8_t *ip = (uint8_t *)&addr;
console_printf("%d.%d.%d.%d/%d\n", ip[0], ip[1], ip[2], ip[3],
port);
memset(&sin, 0, sizeof(sin));
sin.msin_len = sizeof(sin);
sin.msin_family = MN_AF_INET;
sin.msin_port = htons(port);
sin.msin_addr.s_addr = addr;
sinp = &sin;
} else {
sinp = NULL;
}
if (net_test_socket2) {
rc = mn_sendto(net_test_socket2, m, (struct mn_sockaddr *)sinp);
} else {
rc = mn_sendto(net_test_socket, m, (struct mn_sockaddr *)sinp);
}
console_printf("mn_sendto() = %d\n", rc);
} else if (!strcmp(argv[1], "peer")) {
if (net_test_socket2) {
rc = mn_getpeername(net_test_socket2, (struct mn_sockaddr *)&sin);
} else {
rc = mn_getpeername(net_test_socket, (struct mn_sockaddr *)&sin);
}
console_printf("mn_getpeername() = %d\n", rc);
uint8_t *ip = (uint8_t *)&sin.msin_addr;
console_printf("%d.%d.%d.%d/%d\n", ip[0], ip[1], ip[2], ip[3],
ntohs(sin.msin_port));
} else if (!strcmp(argv[1], "recv")) {
if (net_test_socket2) {
rc = mn_recvfrom(net_test_socket2, &m, (struct mn_sockaddr *)&sin);
} else {
rc = mn_recvfrom(net_test_socket, &m, (struct mn_sockaddr *)&sin);
}
console_printf("mn_recvfrom() = %d\n", rc);
if (m) {
uint8_t *ip = (uint8_t *)&sin.msin_addr;
console_printf("%d.%d.%d.%d/%d\n", ip[0], ip[1], ip[2], ip[3],
ntohs(sin.msin_port));
m->om_data[m->om_len] = '\0';
console_printf("received %d bytes >%s<\n",
OS_MBUF_PKTHDR(m)->omp_len, (char *)m->om_data);
os_mbuf_free_chain(m);
}
} else if (!strcmp(argv[1], "mcast_join") ||
!strcmp(argv[1], "mcast_leave")) {
struct mn_mreq mm;
int val;
if (argc < 4) {
return 0;
}
val = strtoul(argv[2], &eptr, 0);
if (*eptr != '\0') {
console_printf("Invalid itf_idx %s\n", argv[2]);
return 0;
}
memset(&mm, 0, sizeof(mm));
mm.mm_idx = val;
mm.mm_family = MN_AF_INET;
if (mn_inet_pton(MN_AF_INET, argv[3], &mm.mm_addr) != 1) {
console_printf("Invalid address %s\n", argv[2]);
return 0;
}
if (!strcmp(argv[1], "mcast_join")) {
val = MN_MCAST_JOIN_GROUP;
} else {
val = MN_MCAST_LEAVE_GROUP;
}
rc = mn_setsockopt(net_test_socket, MN_SO_LEVEL, val, &mm);
console_printf("mn_setsockopt() = %d\n", rc);
} else if (!strcmp(argv[1], "listif")) {
struct mn_itf itf;
struct mn_itf_addr itf_addr;
char addr_str[48];
memset(&itf, 0, sizeof(itf));
while (1) {
rc = mn_itf_getnext(&itf);
if (rc) {
break;
}
console_printf("%d: %x %s\n", itf.mif_idx, itf.mif_flags,
itf.mif_name);
memset(&itf_addr, 0, sizeof(itf_addr));
while (1) {
rc = mn_itf_addr_getnext(&itf, &itf_addr);
if (rc) {
break;
}
mn_inet_ntop(itf_addr.mifa_family, &itf_addr.mifa_addr,
addr_str, sizeof(addr_str));
console_printf(" %s/%d\n", addr_str, itf_addr.mifa_plen);
}
}
#if MYNEWT_VAL(MCU_STM32F4) || MYNEWT_VAL(MCU_STM32F7)
} else if (!strcmp(argv[1], "mii")) {
extern int stm32_mii_dump(int (*func)(const char *fmt, ...));
stm32_mii_dump(console_printf);
#endif
/*
} else if (!strcmp(argv[1], "service")) {
inet_def_service_init(os_eventq_dflt_get());
*/
#if MYNEWT_VAL(BUILD_WITH_OIC)
} else if (!strcmp(argv[1], "oic")) {
oc_main_init((oc_handler_t *)&omgr_oc_handler);
#endif
} else {
console_printf("unknown cmd\n");
}
return 0;
}
/* wolfssl command */
static int wolfssl_cli(int argc, char **argv);
struct shell_cmd wolfssl_cmd = {
.sc_cmd = "wolfssl",
.sc_cmd_func = wolfssl_cli,
};
static WOLFSSL_CTX* wolfsslCtx = NULL;
static WOLFSSL* ssl = NULL;
static int wolfssl_ctx_init() {
if(wolfsslCtx && ssl) {
console_printf("ERROR: already initialize WOLFSSL_CTX and ssl\n");
return -1; // already init
}
/* Create and initialize WOLFSSL_CTX */
if ((wolfsslCtx = wolfSSL_CTX_new(wolfTLSv1_2_client_method())) == NULL) {
console_printf("ERROR: failed to create WOLFSSL_CTX\n");
return -1;
}
int ret = wolfSSL_CTX_load_verify_buffer(wolfsslCtx, ca_cert_der_2048, sizeof_ca_cert_der_2048, SSL_FILETYPE_ASN1);
if(ret != SSL_SUCCESS) {
console_printf("Error %d loading CA cert\n", ret);
return ret;
}
wolfSSL_CTX_set_verify(wolfsslCtx, SSL_VERIFY_NONE, 0);
/* Create a WOLFSSL object */
if ((ssl = wolfSSL_new(wolfsslCtx)) == NULL) {
console_printf("ERROR: failed to create WOLFSSL object\n");
return -1;
}
console_printf("wolfssl contexts are initialized\n");
return 0;
}
static void wolfssl_ctx_clear() {
if(ssl) {
wolfSSL_free(ssl); /* Free the wolfSSL object */
ssl = NULL;
}
if(wolfsslCtx) {
wolfSSL_CTX_free(wolfsslCtx); /* Free the wolfSSL context object */
wolfsslCtx = NULL;
}
console_printf("clear wolfssl contexts\n");
}
static int
wolfssl_cli(int argc, char **argv)
{
int rc;
int err = 0;
char errBuffer[80];
struct os_mbuf *m;
if (argc < 2) {
return 0;
}
const char *subCommand = argv[1];
if(!strcmp(subCommand, "init")) {
wolfssl_ctx_init();
wolfSSL_SetIO_Mynewt(ssl, net_test_socket, &net_test_sin);
console_printf("wolfSSL ctx initialize\n");
} else if(!strcmp(subCommand, "clear")) {
wolfssl_ctx_clear();
console_printf("wolfSSL ctx clear\n");
} else if(!strcmp(subCommand, "connect")) {
rc = wolfSSL_connect(ssl);
if(rc != SSL_SUCCESS) {
err = wolfSSL_get_error(ssl, 0);
console_printf("ERROR: wolfSSL_connect rc:%d err:%d\n", rc, err);
return 0;
}
console_printf("wolfSSL_connect() = %d\n", rc);
} else if(!strcmp(subCommand, "write")) {
char *str = "GET /index.html HTTP/1.0\r\n\r\n";
int len;
if(argc > 3) {
str = argv[2];
}
len = strlen(str);
rc = wolfSSL_write(ssl, str, len);
if(rc != len) {
err = wolfSSL_get_error(ssl, 0);
console_printf("ERROR: wolfSSL_write rc:%d err:%d\n", rc, err);
return -1;
}
console_printf("wolfSSL_write() = %dL\n", rc);
} else if(!strcmp(subCommand, "read")) {
char buff[256];
rc = 0;
while(rc >= 0) {
memset(buff, 0, sizeof(buff));
rc = wolfSSL_read(ssl, buff, sizeof(buff)-1);
if(rc < 0) {
err = wolfSSL_get_error(ssl, 0);
console_printf("ERROR: wolfSSL_read rc:%d err:%d\n", rc, err);
return 0;
}
console_printf("%.*s\n", rc, buff);
}
console_printf("\n", buff);
} else {
console_printf("ERROR: unknown command: %s\n", subCommand);
}
return 0;
}
#if MYNEWT_VAL(BUILD_WITH_OIC)
static void
app_get_light(oc_request_t *request, oc_interface_mask_t interface)
{
bool value;
if (hal_gpio_read(LED_BLINK_PIN)) {
value = true;
} else {
value = false;
}
oc_rep_start_root_object();
switch (interface) {
case OC_IF_BASELINE:
oc_process_baseline_interface(request->resource);
case OC_IF_A:
oc_rep_set_boolean(root, value, value);
break;
default:
break;
}
oc_rep_end_root_object();
oc_send_response(request, OC_STATUS_OK);
}
static void
app_set_light(oc_request_t *request, oc_interface_mask_t interface)
{
bool value;
int len;
uint16_t data_off;
struct os_mbuf *m;
struct cbor_attr_t attrs[] = {
[0] = {
.attribute = "value",
.type = CborAttrBooleanType,
.addr.boolean = &value,
.dflt.boolean = false
},
[1] = {
}
};
len = coap_get_payload(request->packet, &m, &data_off);
if (cbor_read_mbuf_attrs(m, data_off, len, attrs)) {
oc_send_response(request, OC_STATUS_BAD_REQUEST);
} else {
hal_gpio_write(LED_BLINK_PIN, value == true);
oc_send_response(request, OC_STATUS_CHANGED);
}
}
static void
omgr_app_init(void)
{
oc_resource_t *res;
oc_init_platform("MyNewt", NULL, NULL);
oc_add_device("/oic/d", "oic.d.light", "MynewtLed", "1.0", "1.0", NULL,
NULL);
res = oc_new_resource("/light/1", 1, 0);
oc_resource_bind_resource_type(res, "oic.r.switch.binary");
oc_resource_bind_resource_interface(res, OC_IF_A);
oc_resource_set_default_interface(res, OC_IF_A);
oc_resource_set_discoverable(res);
oc_resource_set_periodic_observable(res, 1);
oc_resource_set_request_handler(res, OC_GET, app_get_light);
oc_resource_set_request_handler(res, OC_PUT, app_set_light);
oc_resource_set_request_handler(res, OC_POST, app_set_light);
oc_add_resource(res);
hal_gpio_init_out(LED_BLINK_PIN, 1);
}
#endif
/**
* main
*
* The main task for the project. This function initializes the packages, calls
* init_tasks to initialize additional tasks (and possibly other objects),
* then starts serving events from default event queue.
*
* @return int NOTE: this function should never return!
*/
int
main(int argc, char **argv)
{
#ifdef ARCH_sim
mcu_sim_parse_args(argc, argv);
#endif
#ifndef ARCH_sim
{
/*
* XXX set mac address when using STM32 ethernet XXX
* XXX move this somewhere else XXX
*/
static uint8_t mac[6]= { 0, 1, 1, 2, 2, 3 };
int stm32_eth_set_hwaddr(uint8_t *addr);
stm32_eth_set_hwaddr(mac);
}
#endif
sysinit();
console_printf("client-tls-mn\n");
cbmem_init(&cbmem, cbmem_buf, MAX_CBMEM_BUF);
log_register("log", &my_log, &log_cbmem_handler, &cbmem, LOG_SYSLEVEL);
/* Initialize wolfSSL */
wolfSSL_Init();
/* wolfSSL_Debugging_ON(); */
shell_cmd_register(&net_test_cmd);
shell_cmd_register(&time_cmd);
shell_cmd_register(&wolfssl_cmd);
#ifdef ARCH_sim
{
time_t t = time(NULL);
/* set dummy wallclock time. */
struct os_timeval utctime;
struct os_timezone tz;
utctime.tv_sec = t;
utctime.tv_usec = 0;
tz.tz_minuteswest = 0;
tz.tz_dsttime = 0;
os_settimeofday(&utctime, &tz);
}
#endif
/*
* As the last thing, process events from default event queue.
*/
while (1) {
os_eventq_run(os_eventq_dflt_get());
}
wolfssl_ctx_clear();
wolfSSL_Cleanup();
}

46
mynewt/setup.sh 100755
View File

@ -0,0 +1,46 @@
#!/bin/sh -e
# this scrypt deploy wolfssl and wolfcrypto source code to mynewt project
# run as bash "mynewt project root directory path"
SCRIPTDIR=`dirname $0`
SCRIPTDIR=`cd $SCRIPTDIR && pwd -P`
WOLFSSL_MYNEWTDIR=${SCRIPTDIR}
WOLFSSL_MYNEWTDIR=`cd $WOLFSSL_MYNEWTDIR && pwd -P`
BASEDIR=${SCRIPTDIR}/../..
BASEDIR=`cd ${BASEDIR} && pwd -P`
if [ $# -ne 1 ]; then
echo "Usage: $0 'mynewt project root directory path'" 1>&2
exit 1
fi
MYNEWT_PROJECT=$1
if [ ! -d $MYNEWT_PROJECT ] || [ ! -f $MYNEWT_PROJECT/project.yml ]; then
echo "target directory is not mynewt project.: $MYNEWT_PROJECT"
exit 1
fi
pushd $MYNEWT_PROJECT > /dev/null
echo "create apps/wolfsslclienttlsmn pkg"
/bin/rm -rf apps/wolfsslclienttlsmn
newt pkg new -t app apps/wolfsslclienttlsmn
/bin/rm -rf apps/wolfsslclienttlsmn/include
/bin/rm -rf apps/wolfsslclienttlsmn/src
/bin/mkdir -p apps/wolfsslclienttlsmn/src
popd > /dev/null # $MYNEWT_PROJECT
# deploy source files and pkg
pushd $BASEDIR > /dev/null
# deploy wolfssl client-tls to apps/wolfsslclienttlsmn
echo "deploy wolfssl client-tls to apps/wolfsslclienttlsmn"
/bin/cp $WOLFSSL_MYNEWTDIR/apps.wolfsslclienttlsmn.pkg.yml $MYNEWT_PROJECT/apps/wolfsslclienttlsmn/pkg.yml
/bin/cp $WOLFSSL_MYNEWTDIR/apps.wolfsslclienttlsmn.syscfg.yml $MYNEWT_PROJECT/apps/wolfsslclienttlsmn/syscfg.yml
/bin/mkdir -p $MYNEWT_PROJECT/apps/wolfsslclienttlsmn/src
/bin/cp $WOLFSSL_MYNEWTDIR/client-tls-mn.c $MYNEWT_PROJECT/apps/wolfsslclienttlsmn/src/main.c
popd > /dev/null # $BASEDIR