int
dtls_handle_read(struct dtls_context_t *ctx) {
int fd;
session_t session;
#define MAX_READ_BUF 2000
static uint8 buf[MAX_READ_BUF];
int len;
fd = *(int *)dtls_get_app_data(ctx);
if (!fd)
return -1;
memset(&session, 0, sizeof(session_t));
session.size = sizeof(session.addr);
len = recvfrom(fd, buf, MAX_READ_BUF, 0,
&session.addr.sa, &session.size);
if (len < 0) {
perror("recvfrom");
return -1;
} else {
unsigned char addrbuf[72];
dsrv_print_addr(&session, addrbuf, sizeof(addrbuf));
dsrv_log(LOG_DEBUG, "got %d bytes from %s\n", len, (char *)addrbuf);
dump((unsigned char *)&session, sizeof(session_t));
PRINTF("\n");
dump(buf, len);
PRINTF("\n");
}
return dtls_handle_message(ctx, &session, buf, len);
}
static eDtlsRet_t CAAdapterNetDtlsDecryptInternal(const stCADtlsAddrInfo_t *srcSession,
uint8_t *buf, uint32_t bufLen)
{
OIC_LOG(DEBUG, NET_DTLS_TAG, "IN");
VERIFY_NON_NULL_RET(srcSession, NET_DTLS_TAG, "Param srcSession is NULL", DTLS_FAIL);
VERIFY_NON_NULL_RET(buf, NET_DTLS_TAG, "Param buf is NULL", DTLS_FAIL);
if (0 == bufLen)
{
OIC_LOG(ERROR, NET_DTLS_TAG, "Given Packet length is equal to zero.");
return DTLS_FAIL;
}
eDtlsRet_t ret = DTLS_FAIL;
if (dtls_handle_message(g_caDtlsContext->dtlsContext, (session_t *)srcSession, buf, bufLen) == 0)
{
OIC_LOG(DEBUG, NET_DTLS_TAG, "dtls_handle_message success");
ret = DTLS_OK;
}
OIC_LOG(DEBUG, NET_DTLS_TAG, "OUT");
return ret;
}
static int
dtls_handle_read(struct dtls_context_t *ctx) {
int *fd;
session_t session;
static uint8 buf[DTLS_MAX_BUF];
int len;
fd = dtls_get_app_data(ctx);
assert(fd);
memset(&session, 0, sizeof(session_t));
session.size = sizeof(session.addr);
len = recvfrom(*fd, buf, sizeof(buf), MSG_TRUNC,
&session.addr.sa, &session.size);
if (len < 0) {
perror("recvfrom");
return -1;
} else {
dtls_debug("got %d bytes from port %d\n", len,
ntohs(session.addr.sin6.sin6_port));
if (sizeof(buf) < len) {
dtls_warn("packet was truncated (%d bytes lost)\n", len - sizeof(buf));
}
}
return dtls_handle_message(ctx, &session, buf, len);
}
int
get_psk_key(struct dtls_context_t *ctx,
const session_t *session,
const unsigned char *id, size_t id_len,
const dtls_psk_key_t **result) {
static const dtls_psk_key_t psk = {
.id = (unsigned char *)"Client_identity",
.id_length = 15,
.key = (unsigned char *)"secretPSK",
.key_length = 9
};
*result = &psk;
return 0;
}
PROCESS(udp_server_process, "UDP server process");
AUTOSTART_PROCESSES(&udp_server_process);
/*---------------------------------------------------------------------------*/
static void
dtls_handle_read(dtls_context_t *ctx) {
session_t session;
if(uip_newdata()) {
uip_ipaddr_copy(&session.addr, &UIP_IP_BUF->srcipaddr);
session.port = UIP_UDP_BUF->srcport;
session.size = sizeof(session.addr) + sizeof(session.port);
dtls_handle_message(ctx, &session, uip_appdata, uip_datalen());
}
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(udp_server_process, ev, data)
{
PROCESS_BEGIN();
print_local_addresses();
dtls_init();
init_dtls();
if (!dtls_context) {
dsrv_log(LOG_EMERG, "cannot create context\n");
PROCESS_EXIT();
}
while(1) {
PROCESS_WAIT_EVENT();
if(ev == tcpip_event) {
dtls_handle_read(dtls_context);
}
#if 0
if (bytes_read > 0) {
/* dtls_handle_message(dtls_context, &the_session, readbuf, bytes_read); */
read_from_peer(dtls_context, &the_session, readbuf, bytes_read);
}
dtls_handle_message(ctx, &session, uip_appdata, bytes_read);
#endif
}
PROCESS_END();
}
int
get_key(struct dtls_context_t *ctx,
const session_t *session,
const unsigned char *id, size_t id_len,
const dtls_key_t **result) {
static const dtls_key_t psk = {
.type = DTLS_KEY_PSK,
.key.psk.id = (unsigned char *)"Client_identity",
.key.psk.id_length = 15,
.key.psk.key = (unsigned char *)"secretPSK",
.key.psk.key_length = 9
};
*result = &psk;
return 0;
}
PROCESS(udp_server_process, "UDP server process");
AUTOSTART_PROCESSES(&udp_server_process);
/*---------------------------------------------------------------------------*/
static void
dtls_handle_read(dtls_context_t *ctx) {
static session_t session;
if(uip_newdata()) {
uip_ipaddr_copy(&session.addr, &UIP_IP_BUF->srcipaddr);
session.port = UIP_UDP_BUF->srcport;
session.size = sizeof(session.addr) + sizeof(session.port);
((char *)uip_appdata)[uip_datalen()] = 0;
PRINTF("Client received message from ");
PRINT6ADDR(&session.addr);
PRINTF(":%d\n", uip_ntohs(session.port));
dtls_handle_message(ctx, &session, uip_appdata, uip_datalen());
}
}
/*---------------------------------------------------------------------------*/
static void
print_local_addresses(void)
{
int i;
uint8_t state;
PRINTF("Client IPv6 addresses: ");
for(i = 0; i < UIP_DS6_ADDR_NB; i++) {
state = uip_ds6_if.addr_list[i].state;
if(uip_ds6_if.addr_list[i].isused &&
(state == ADDR_TENTATIVE || state == ADDR_PREFERRED)) {
PRINT6ADDR(&uip_ds6_if.addr_list[i].ipaddr);
PRINTF("\n");
}
}
}
/*---------------------------------------------------------------------------*/
static void
dtls_handle_read(dtls_context_t *ctx) {
session_t session;
if(uip_newdata()) {
dtls_session_init(&session);
uip_ipaddr_copy(&session.addr, &UIP_IP_BUF->srcipaddr);
session.port = UIP_UDP_BUF->srcport;
dtls_handle_message(ctx, &session, uip_appdata, uip_datalen());
}
}
int connection_handle_packet(dtls_connection_t *connP, uint8_t * buffer, size_t numBytes){
if (connP->dtlsSession != NULL)
{
// Let liblwm2m respond to the query depending on the context
int result = dtls_handle_message(connP->dtlsContext, connP->dtlsSession, buffer, numBytes);
if (result !=0) {
printf("error dtls handling message %d\n",result);
}
return result;
} else {
// no security, just give the plaintext buffer to liblwm2m
lwm2m_handle_packet(connP->lwm2mH, buffer, numBytes, (void*)connP);
return 0;
}
}
/*---------------------------------------------------------------------------*/
static void
dtls_handle_read(dtls_context_t *ctx) {
static session_t session;
if(uip_newdata()) {
uip_ipaddr_copy(&session.addr, &UIP_IP_BUF->srcipaddr);
session.port = UIP_UDP_BUF->srcport;
session.size = sizeof(session.addr) + sizeof(session.port);
((char *)uip_appdata)[uip_datalen()] = 0;
PRINTF("Client received message from ");
PRINT6ADDR(&session.addr);
PRINTF(":%d\n", uip_ntohs(session.port));
dtls_handle_message(ctx, &session, uip_appdata, uip_datalen());
}
}
/*---------------------------------------------------------------------------*/
int coap_context_wait_data(coap_context_t *coap_ctx, int32_t ticks)
{
struct net_buf *buf;
buf = net_receive(coap_ctx->net_ctx, ticks);
if (buf) {
session_t session;
int ret;
uip_ipaddr_copy(&session.addr.ipaddr, &UIP_IP_BUF(buf)->srcipaddr);
session.addr.port = UIP_UDP_BUF(buf)->srcport;
session.size = sizeof(session.addr);
session.ifindex = 1;
PRINTF("coap-context: got dtls message from ");
PRINT6ADDR(&session.addr.ipaddr);
PRINTF(":%d %u bytes\n", uip_ntohs(session.addr.port), uip_appdatalen(buf));
PRINTF("Received appdata %p appdatalen %d\n",
ip_buf_appdata(buf), ip_buf_appdatalen(buf));
coap_ctx->buf = buf;
ret = dtls_handle_message(coap_ctx->dtls_context, &session,
ip_buf_appdata(buf), ip_buf_appdatalen(buf));
/* We always release the buffer here as this buffer is never sent
* to network anyway.
*/
if (coap_ctx->buf) {
ip_buf_unref(coap_ctx->buf);
coap_ctx->buf = NULL;
}
return ret;
}
return 0;
}
int main()
{
int result;
lwm2m_object_t * objArray[4];
printf("Start\n");
ethSetup();
printf("Initializing tinydtls\n");
// fake loading of PSK..
psk_id_length = strlen(PSK_DEFAULT_IDENTITY);
psk_key_length = strlen(PSK_DEFAULT_KEY);
memcpy(psk_id, PSK_DEFAULT_IDENTITY, psk_id_length);
memcpy(psk_key, PSK_DEFAULT_KEY, psk_key_length);
printf("Init\n");
dtls_init();
printf("New context\n");
dtls_context = dtls_new_context(&lwm2mH);
if (dtls_context == NULL) {
printf("error creating the dtls context\n");
}
printf("Setting handlers\n");
dtls_set_handler(dtls_context, &cb);
if (!dtls_context) {
printf("can't create dtls_context\n");
exit(-1);
}
printf("Initialazing Wakaama\n");
// create objects
objArray[0] = get_security_object(123, "coaps://5.39.83.206:5684", false);
securityObjP = objArray[0];
objArray[1] = get_server_object(123, "U", 20, false);
serverObject = objArray[1];
objArray[2] = get_object_device();
objArray[3] = get_object_firmware();
/*
* The liblwm2m library is now initialized with the functions that will be in
* charge of communication
*/
lwm2mH = lwm2m_init(prv_connect_server, prv_buffer_send, NULL);
if (NULL == lwm2mH)
{
fprintf(stderr, "lwm2m_init() failed\r\n");
return -1;
}
// configure the liblwm2m lib
result = lwm2m_configure(lwm2mH, "julien", NULL, 4, objArray);
if (result != 0)
{
printf("lwm2m_configure() failed: 0x%X\n", result);
return -1;
}
// start
result = lwm2m_start(lwm2mH);
if (result != 0)
{
printf("lwm2m_start() failed: 0x%X\n", result);
return -1;
}
// main loop
while (true) {
char buffer[1024];
Endpoint server;
printf("loop...\n");
struct timeval timeout;
timeout.tv_sec = 10;
timeout.tv_usec = 0;
result = lwm2m_step(lwm2mH, &timeout);
if (result != 0)
{
printf("lwm2m_step error %d\n", result);
}
int n = udp.receiveFrom(server, buffer, sizeof(buffer));
printf("Received packet from: %s of size %d\n", server.get_address(), n);
if (n>0) {
// TODO: find connection
connection_t * connP = connList;
while(connP != NULL) {
if (strcmp(connP->host, server.get_address()) == 0)
{
printf("found connection\n");
// is it a secure connection?
if (connP->dtlsSession != NULL) {
printf("dtls session\n");
result = dtls_handle_message(dtls_context, connP->dtlsSession, buffer, n);
printf("dtls handle message %d\n",result);
} else {
printf("nosec session\n");
lwm2m_handle_packet(lwm2mH, (uint8_t*)buffer, n, (void*)connP);
}
break;
}
}
if (connP == NULL) printf("no connection\n");
}
}
}
static int
get_key(struct dtls_context_t *ctx,
const session_t *session,
const unsigned char *id, size_t id_len,
const dtls_key_t **result) {
static const dtls_key_t psk = {
.type = DTLS_KEY_PSK,
.key.psk.id = (unsigned char *)DTLS_IDENTITY_HINT,
.key.psk.id_length = DTLS_IDENTITY_HINT_LENGTH,
.key.psk.key = (unsigned char *)DTLS_PSK_KEY,
.key.psk.key_length = DTLS_PSK_KEY_LENGTH
};
*result = &psk;
return 0;
}
#else
static int
get_psk_key(struct dtls_context_t *ctx,
const session_t *session,
const unsigned char *id, size_t id_len,
const dtls_psk_key_t **result) {
static const dtls_psk_key_t psk = {
.id = (unsigned char *)DTLS_IDENTITY_HINT,
.id_length = DTLS_IDENTITY_HINT_LENGTH,
.key = (unsigned char *)DTLS_PSK_KEY,
.key_length = DTLS_PSK_KEY_LENGTH
};
*result = &psk;
return 0;
}
#endif
/*-----------------------------------------------------------------------------------*/
void
coap_init_communication_layer(uint16_t port)
{
static dtls_handler_t cb = {
.write = send_to_peer,
.read = read_from_peer,
.event = NULL,
#if DTLS_VERSION_0_4_0
.get_key = get_key
#else
.get_psk_key = get_psk_key,
.get_ecdsa_key = NULL,
.verify_ecdsa_key = NULL
#endif
};
server_conn = udp_new(NULL, 0, NULL);
udp_bind(server_conn, port);
dtls_set_log_level(LOG_DEBUG);
dtls_context = dtls_new_context(server_conn);
if (dtls_context)
dtls_set_handler(dtls_context, &cb);
/* new connection with remote host */
printf("COAP-DTLS listening on port %u\n", uip_ntohs(server_conn->lport));
}
/*-----------------------------------------------------------------------------------*/
static int
send_to_peer(struct dtls_context_t *ctx,
session_t *session, uint8 *data, size_t len) {
struct uip_udp_conn *conn = (struct uip_udp_conn *)dtls_get_app_data(ctx);
uip_ipaddr_copy(&conn->ripaddr, &session->addr);
conn->rport = session->port;
uip_udp_packet_send(conn, data, len);
/* Restore server connection to allow data from any node */
memset(&conn->ripaddr, 0, sizeof(conn->ripaddr));
memset(&conn->rport, 0, sizeof(conn->rport));
return len;
}
/*-----------------------------------------------------------------------------------*/
void
coap_send_message(context_t * ctx, uip_ipaddr_t *addr, uint16_t port, uint8_t *data, uint16_t length)
{
session_t session;
dtls_session_init(&session);
uip_ipaddr_copy(&session.addr, addr);
session.port = port;
dtls_write(ctx, &session, data, length);
}
/*-----------------------------------------------------------------------------------*/
static int
read_from_peer(struct dtls_context_t *ctx,
session_t *session, uint8 *data, size_t len) {
uip_len = len;
memmove(uip_appdata, data, len);
coap_receive(ctx);
return 0;
}
/*-----------------------------------------------------------------------------------*/
void
coap_handle_receive()
{
session_t session;
if(uip_newdata()) {
dtls_session_init(&session);
uip_ipaddr_copy(&session.addr, &UIP_IP_BUF->srcipaddr);
session.port = UIP_UDP_BUF->srcport;
dtls_handle_message(dtls_context, &session, uip_appdata, uip_datalen());
}
}