| /* |
| * Copyright (c) 2016 Intel Corporation |
| * |
| * Copyright (c) 2013, Institute for Pervasive Computing, ETH Zurich |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. Neither the name of the Institute nor the names of its contributors |
| * may be used to endorse or promote products derived from this software |
| * without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND |
| * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE |
| * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| * |
| * This file is part of the Contiki operating system. |
| */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include "os/mynewt.h" |
| |
| #include "oic/port/mynewt/config.h" |
| /* OIC Stack headers */ |
| #include "oic/oc_buffer.h" |
| #include "oic/oc_ri.h" |
| #include "messaging/coap/engine.h" |
| |
| #ifdef OC_CLIENT |
| #include "oic/oc_client_state.h" |
| #endif |
| |
| /*---------------------------------------------------------------------------*/ |
| /*- Internal API ------------------------------------------------------------*/ |
| /*---------------------------------------------------------------------------*/ |
| int |
| coap_receive(struct os_mbuf **mp) |
| { |
| /* static declaration reduces stack peaks and program code size */ |
| /* this way the packet can be treated as pointer as usual */ |
| struct os_mbuf *m; |
| static struct coap_packet_rx message[1]; |
| static struct coap_packet response[1]; |
| static coap_transaction_t *transaction = NULL; |
| struct os_mbuf *rsp; |
| struct oc_endpoint endpoint; /* XXX */ |
| |
| erbium_status_code = NO_ERROR; |
| |
| OC_LOG(INFO, "CoAP: received datalen=%u\n", OS_MBUF_PKTLEN(*mp)); |
| |
| memcpy(&endpoint, OC_MBUF_ENDPOINT(*mp), |
| oc_endpoint_size(OC_MBUF_ENDPOINT(*mp))); |
| erbium_status_code = coap_parse_message(message, mp); |
| if (erbium_status_code != NO_ERROR) { |
| goto out; |
| } |
| |
| m = *mp; |
| /*TODO duplicates suppression, if required by application */ |
| OC_LOG(DEBUG, " Parsed: CoAP version: %u, token: 0x%02X%02X, mid: %u\n", |
| message->version, message->token[0], message->token[1], |
| message->mid); |
| switch (message->type) { |
| case COAP_TYPE_CON: |
| OC_LOG(DEBUG, " type: CON\n"); |
| break; |
| case COAP_TYPE_NON: |
| OC_LOG(DEBUG, " type: NON\n"); |
| break; |
| case COAP_TYPE_ACK: |
| OC_LOG(DEBUG, " type: ACK\n"); |
| break; |
| case COAP_TYPE_RST: |
| OC_LOG(DEBUG, " type: RST\n"); |
| break; |
| default: |
| break; |
| } |
| |
| if (message->code >= COAP_GET && message->code <= COAP_DELETE) { |
| /* handle requests */ |
| switch (message->code) { |
| case COAP_GET: |
| OC_LOG(DEBUG, " method: GET\n"); |
| break; |
| case COAP_PUT: |
| OC_LOG(DEBUG, " method: PUT\n"); |
| break; |
| case COAP_POST: |
| OC_LOG(DEBUG, " method: POST\n"); |
| break; |
| case COAP_DELETE: |
| OC_LOG(DEBUG, " method: DELETE\n"); |
| break; |
| } |
| |
| OC_LOG(DEBUG, " Payload: %d bytes\n", message->payload_len); |
| |
| /* use transaction buffer for response to confirmable request */ |
| transaction = coap_new_transaction(message->mid, OC_MBUF_ENDPOINT(m)); |
| if (!transaction) { |
| erbium_status_code = SERVICE_UNAVAILABLE_5_03; |
| coap_error_message = "NoFreeTraBuffer"; |
| goto out; |
| } |
| |
| uint32_t block_num = 0; |
| uint16_t block_size = COAP_MAX_BLOCK_SIZE; |
| uint32_t block_offset = 0; |
| int32_t new_offset = 0; |
| |
| /* prepare response */ |
| if (message->type == COAP_TYPE_CON) { |
| /* reliable CON requests are answered with an ACK */ |
| coap_init_message(response, COAP_TYPE_ACK, CONTENT_2_05, |
| message->mid); |
| } else { |
| /* unreliable NON requests are answered with a NON */ |
| coap_init_message(response, COAP_TYPE_NON, CONTENT_2_05, |
| coap_get_mid()); |
| /* mirror token */ |
| } |
| if (message->token_len) { |
| coap_set_token(response, message->token, message->token_len); |
| /* get offset for blockwise transfers */ |
| } |
| if (coap_get_header_block2(message, &block_num, NULL, |
| &block_size, &block_offset)) { |
| OC_LOG(DEBUG, " Blockwise: block request %u (%u/%u) @ %u bytes\n", |
| (unsigned int) block_num, block_size, |
| COAP_MAX_BLOCK_SIZE, (unsigned int) block_offset); |
| block_size = MIN(block_size, COAP_MAX_BLOCK_SIZE); |
| new_offset = block_offset; |
| } |
| |
| if (oc_ri_invoke_coap_entity_handler(message, response, &new_offset, |
| OC_MBUF_ENDPOINT(m))) { |
| if (erbium_status_code == NO_ERROR) { |
| /* |
| * TODO coap_handle_blockwise(request, response, |
| * start_offset, end_offset); |
| */ |
| |
| /* resource is unaware of Block1 */ |
| if (IS_OPTION(message, COAP_OPTION_BLOCK1) && |
| response->code < BAD_REQUEST_4_00 && |
| !IS_OPTION(response, COAP_OPTION_BLOCK1)) { |
| OC_LOG(ERROR, " Block1 option NOT IMPLEMENTED\n"); |
| |
| erbium_status_code = NOT_IMPLEMENTED_5_01; |
| coap_error_message = "NoBlock1Support"; |
| |
| /* client requested Block2 transfer */ |
| } else if (IS_OPTION(message, COAP_OPTION_BLOCK2)) { |
| |
| /* |
| * Unchanged new_offset indicates that resource is |
| * unaware of blockwise transfer |
| */ |
| if (new_offset == block_offset) { |
| OC_LOG(DEBUG, " Block: unaware resource %u/%u\n", |
| response->payload_len, block_size); |
| if (block_offset >= response->payload_len) { |
| response->code = BAD_OPTION_4_02; |
| rsp = os_msys_get_pkthdr(0, 0); |
| if (rsp) { |
| os_mbuf_copyinto(rsp, 0, "BlockOutOfScope", 15); |
| response->payload_m = rsp; |
| response->payload_len = 15; |
| } |
| /* a const char str[] and sizeof(str) |
| produces larger code size */ |
| } else { |
| coap_set_header_block2(response, block_num, |
| response->payload_len - block_offset > |
| block_size, block_size); |
| response->payload_len = MIN(response->payload_len - |
| block_offset, |
| block_size); |
| } /* if(valid offset) */ |
| |
| /* resource provides chunk-wise data */ |
| } else { |
| OC_LOG(DEBUG, " Block: aware resource, off %d\n", |
| (int) new_offset); |
| coap_set_header_block2(response, block_num, |
| new_offset != -1 || |
| response->payload_len > block_size, |
| block_size); |
| |
| if (response->payload_len > block_size) { |
| response->payload_len = block_size; |
| } |
| } /* if(resource aware of blockwise) */ |
| |
| /* Resource requested Block2 transfer */ |
| } else if (new_offset != 0) { |
| OC_LOG(DEBUG, " block: no block option, using block sz %u\n", |
| COAP_MAX_BLOCK_SIZE); |
| |
| coap_set_header_block2(response, 0, new_offset != -1, |
| COAP_MAX_BLOCK_SIZE); |
| response->payload_len = MIN(response->payload_len, |
| COAP_MAX_BLOCK_SIZE); |
| } /* blockwise transfer handling */ |
| } /* no errors/hooks */ |
| /* successful service callback */ |
| /* serialize response */ |
| } |
| if (erbium_status_code == NO_ERROR) { |
| if (coap_serialize_message(response, transaction->m)) { |
| erbium_status_code = PACKET_SERIALIZATION_ERROR; |
| } |
| transaction->type = response->type; |
| } |
| } else { // Fix this |
| /* handle responses */ |
| if (message->type == COAP_TYPE_CON) { |
| erbium_status_code = EMPTY_ACK_RESPONSE; |
| } else if (message->type == COAP_TYPE_ACK) { |
| /* transactions are closed through lookup below */ |
| } else if (message->type == COAP_TYPE_RST) { |
| #ifdef OC_SERVER |
| /* cancel possible subscriptions */ |
| coap_remove_observer_by_mid(OC_MBUF_ENDPOINT(m), message->mid); |
| #endif |
| } |
| |
| /* Open transaction now cleared for ACK since mid matches */ |
| if ((transaction = coap_get_transaction_by_mid(message->mid))) { |
| coap_clear_transaction(transaction); |
| } |
| /* if(ACKed transaction) */ |
| transaction = NULL; |
| |
| #ifdef OC_CLIENT |
| /* |
| * ACKs and RSTs sent to oc_ri.. RSTs cleared, ACKs sent to |
| * client. |
| */ |
| oc_ri_invoke_client_cb(message, OC_MBUF_ENDPOINT(m)); |
| #endif |
| |
| } /* request or response */ |
| |
| out: |
| /* if(parsed correctly) */ |
| if (erbium_status_code == NO_ERROR) { |
| if (transaction) { // Server transactions sent from here |
| coap_send_transaction(transaction); |
| } |
| } else if (erbium_status_code == CLEAR_TRANSACTION) { |
| OC_LOG(DEBUG, " Clearing transaction for manual response\n"); |
| /* used in server for separate response */ |
| coap_clear_transaction(transaction); |
| } |
| #ifdef OC_CLIENT |
| else if (erbium_status_code == EMPTY_ACK_RESPONSE) { |
| coap_init_message(response, COAP_TYPE_ACK, 0, message->mid); |
| struct os_mbuf *m_rsp = oc_allocate_mbuf(&endpoint); |
| if (m_rsp) { |
| if (!coap_serialize_message(response, m_rsp)) { |
| coap_send_message(m_rsp, 0); |
| } else { |
| os_mbuf_free_chain(m_rsp); |
| } |
| } |
| } |
| #endif /* OC_CLIENT */ |
| #ifdef OC_SERVER |
| else { // framework errors handled here |
| coap_message_type_t reply_type = COAP_TYPE_RST; |
| |
| coap_clear_transaction(transaction); |
| |
| coap_init_message(response, reply_type, SERVICE_UNAVAILABLE_5_03, |
| message->mid); |
| |
| struct os_mbuf *m_rsp = oc_allocate_mbuf(&endpoint); |
| if (m_rsp) { |
| if (!coap_serialize_message(response, m_rsp)) { |
| coap_send_message(m_rsp, 0); |
| } else { |
| os_mbuf_free_chain(m_rsp); |
| } |
| } |
| } |
| #endif /* OC_SERVER */ |
| |
| /* if(new data) */ |
| return erbium_status_code; |
| } |
| |
| void |
| coap_engine_init(void) |
| { |
| coap_init_connection(); |
| coap_transaction_init(); |
| #ifdef OC_SERVER |
| #if MYNEWT_VAL(OC_SEPARATE_RESPONSES) |
| coap_separate_init(); |
| #endif |
| coap_observe_init(); |
| #endif |
| } |
