terence zhang
pick up wakaama files from https://github.com/eclipse/wakaama
Diff: core/packet.c
- Revision:
- 0:1fa43ab66921
diff -r 000000000000 -r 1fa43ab66921 core/packet.c
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/packet.c Wed Apr 19 11:30:02 2017 +0000
@@ -0,0 +1,443 @@
+/*******************************************************************************
+ *
+ * Copyright (c) 2013, 2014 Intel Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * The Eclipse Distribution License is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ * David Navarro, Intel Corporation - initial API and implementation
+ * domedambrosio - Please refer to git log
+ * Fabien Fleutot - Please refer to git log
+ * Fabien Fleutot - Please refer to git log
+ * Simon Bernard - Please refer to git log
+ * Toby Jaffey - Please refer to git log
+ * Pascal Rieux - Please refer to git log
+ * Bosch Software Innovations GmbH - Please refer to git log
+ *
+ *******************************************************************************/
+
+/*
+ Copyright (c) 2013, 2014 Intel Corporation
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ * 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.
+ * Neither the name of Intel Corporation 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 COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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.
+
+ David Navarro <david.navarro@intel.com>
+
+*/
+
+/*
+Contains code snippets which are:
+
+ * 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.
+
+*/
+
+
+#include "internals.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <stdio.h>
+
+
+static void handle_reset(lwm2m_context_t * contextP,
+ void * fromSessionH,
+ coap_packet_t * message)
+{
+#ifdef LWM2M_CLIENT_MODE
+ LOG("Entering");
+ observe_cancel(contextP, message->mid, fromSessionH);
+#endif
+}
+
+static coap_status_t handle_request(lwm2m_context_t * contextP,
+ void * fromSessionH,
+ coap_packet_t * message,
+ coap_packet_t * response)
+{
+ lwm2m_uri_t * uriP;
+ coap_status_t result = COAP_IGNORE;
+
+ LOG("Entering");
+
+#ifdef LWM2M_CLIENT_MODE
+ uriP = uri_decode(contextP->altPath, message->uri_path);
+#else
+ uriP = uri_decode(NULL, message->uri_path);
+#endif
+
+ if (uriP == NULL) return COAP_400_BAD_REQUEST;
+
+ switch(uriP->flag & LWM2M_URI_MASK_TYPE)
+ {
+#ifdef LWM2M_CLIENT_MODE
+ case LWM2M_URI_FLAG_DM:
+ {
+ lwm2m_server_t * serverP;
+
+ serverP = utils_findServer(contextP, fromSessionH);
+ if (serverP != NULL)
+ {
+ result = dm_handleRequest(contextP, uriP, serverP, message, response);
+ }
+#ifdef LWM2M_BOOTSTRAP
+ else
+ {
+ serverP = utils_findBootstrapServer(contextP, fromSessionH);
+ if (serverP != NULL)
+ {
+ result = bootstrap_handleCommand(contextP, uriP, serverP, message, response);
+ }
+ }
+#endif
+ }
+ break;
+
+#ifdef LWM2M_BOOTSTRAP
+ case LWM2M_URI_FLAG_DELETE_ALL:
+ if (COAP_DELETE != message->code)
+ {
+ result = COAP_400_BAD_REQUEST;
+ }
+ else
+ {
+ result = bootstrap_handleDeleteAll(contextP, fromSessionH);
+ }
+ break;
+
+ case LWM2M_URI_FLAG_BOOTSTRAP:
+ if (message->code == COAP_POST)
+ {
+ result = bootstrap_handleFinish(contextP, fromSessionH);
+ }
+ break;
+#endif
+#endif
+
+#ifdef LWM2M_SERVER_MODE
+ case LWM2M_URI_FLAG_REGISTRATION:
+ result = registration_handleRequest(contextP, uriP, fromSessionH, message, response);
+ break;
+#endif
+#ifdef LWM2M_BOOTSTRAP_SERVER_MODE
+ case LWM2M_URI_FLAG_BOOTSTRAP:
+ result = bootstrap_handleRequest(contextP, uriP, fromSessionH, message, response);
+ break;
+#endif
+ default:
+ result = COAP_IGNORE;
+ break;
+ }
+
+ coap_set_status_code(response, result);
+
+ if (COAP_IGNORE < result && result < COAP_400_BAD_REQUEST)
+ {
+ result = NO_ERROR;
+ }
+
+ lwm2m_free(uriP);
+ return result;
+}
+
+/* This function is an adaptation of function coap_receive() from Erbium's er-coap-13-engine.c.
+ * Erbium is Copyright (c) 2013, Institute for Pervasive Computing, ETH Zurich
+ * All rights reserved.
+ */
+void lwm2m_handle_packet(lwm2m_context_t * contextP,
+ uint8_t * buffer,
+ int length,
+ void * fromSessionH)
+{
+ coap_status_t coap_error_code = NO_ERROR;
+ static coap_packet_t message[1];
+ static coap_packet_t response[1];
+
+ LOG("Entering");
+ coap_error_code = coap_parse_message(message, buffer, (uint16_t)length);
+ if (coap_error_code == NO_ERROR)
+ {
+ LOG_ARG("Parsed: ver %u, type %u, tkl %u, code %u.%.2u, mid %u, Content type: %d",
+ message->version, message->type, message->token_len, message->code >> 5, message->code & 0x1F, message->mid, message->content_type);
+ LOG_ARG("Payload: %.*s", message->payload_len, message->payload);
+ if (message->code >= COAP_GET && message->code <= COAP_DELETE)
+ {
+ uint32_t block_num = 0;
+ uint16_t block_size = REST_MAX_CHUNK_SIZE;
+ uint32_t block_offset = 0;
+ int64_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, COAP_205_CONTENT, message->mid);
+ }
+ else
+ {
+ /* Unreliable NON requests are answered with a NON as well. */
+ coap_init_message(response, COAP_TYPE_NON, COAP_205_CONTENT, contextP->nextMID++);
+ }
+
+ /* mirror token */
+ if (message->token_len)
+ {
+ coap_set_header_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))
+ {
+ LOG_ARG("Blockwise: block request %u (%u/%u) @ %u bytes", block_num, block_size, REST_MAX_CHUNK_SIZE, block_offset);
+ block_size = MIN(block_size, REST_MAX_CHUNK_SIZE);
+ new_offset = block_offset;
+ }
+
+ /* handle block1 option */
+ if (IS_OPTION(message, COAP_OPTION_BLOCK1))
+ {
+#ifdef LWM2M_CLIENT_MODE
+ // get server
+ lwm2m_server_t * serverP;
+ serverP = utils_findServer(contextP, fromSessionH);
+#ifdef LWM2M_BOOTSTRAP
+ if (serverP == NULL)
+ {
+ serverP = utils_findBootstrapServer(contextP, fromSessionH);
+ }
+#endif
+ if (serverP == NULL)
+ {
+ coap_error_code = COAP_500_INTERNAL_SERVER_ERROR;
+ }
+ else
+ {
+ uint32_t block1_num;
+ uint8_t block1_more;
+ uint16_t block1_size;
+ uint8_t * complete_buffer = NULL;
+ size_t complete_buffer_size;
+
+ // parse block1 header
+ coap_get_header_block1(message, &block1_num, &block1_more, &block1_size, NULL);
+ LOG_ARG("Blockwise: block1 request NUM %u (SZX %u/ SZX Max%u) MORE %u", block1_num, block1_size, REST_MAX_CHUNK_SIZE, block1_more);
+
+ // handle block 1
+ coap_error_code = coap_block1_handler(&serverP->block1Data, message->mid, message->payload, message->payload_len, block1_size, block1_num, block1_more, &complete_buffer, &complete_buffer_size);
+
+ // if payload is complete, replace it in the coap message.
+ if (coap_error_code == NO_ERROR)
+ {
+ message->payload = complete_buffer;
+ message->payload_len = complete_buffer_size;
+ }
+ else if (coap_error_code == COAP_231_CONTINUE)
+ {
+ block1_size = MIN(block1_size, REST_MAX_CHUNK_SIZE);
+ coap_set_header_block1(response,block1_num, block1_more,block1_size);
+ }
+ }
+#else
+ coap_error_code = COAP_501_NOT_IMPLEMENTED;
+#endif
+ }
+ if (coap_error_code == NO_ERROR)
+ {
+ coap_error_code = handle_request(contextP, fromSessionH, message, response);
+ }
+ if (coap_error_code==NO_ERROR)
+ {
+ if ( IS_OPTION(message, COAP_OPTION_BLOCK2) )
+ {
+ /* unchanged new_offset indicates that resource is unaware of blockwise transfer */
+ if (new_offset==block_offset)
+ {
+ LOG_ARG("Blockwise: unaware resource with payload length %u/%u", response->payload_len, block_size);
+ if (block_offset >= response->payload_len)
+ {
+ LOG("handle_incoming_data(): block_offset >= response->payload_len");
+
+ response->code = COAP_402_BAD_OPTION;
+ coap_set_payload(response, "BlockOutOfScope", 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);
+ coap_set_payload(response, response->payload+block_offset, MIN(response->payload_len - block_offset, block_size));
+ } /* if (valid offset) */
+ }
+ else
+ {
+ /* resource provides chunk-wise data */
+ LOG_ARG("Blockwise: blockwise resource, new offset %d", (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) coap_set_payload(response, response->payload, block_size);
+ } /* if (resource aware of blockwise) */
+ }
+ else if (new_offset!=0)
+ {
+ LOG_ARG("Blockwise: no block option for blockwise resource, using block size %u", REST_MAX_CHUNK_SIZE);
+
+ coap_set_header_block2(response, 0, new_offset!=-1, REST_MAX_CHUNK_SIZE);
+ coap_set_payload(response, response->payload, MIN(response->payload_len, REST_MAX_CHUNK_SIZE));
+ } /* if (blockwise request) */
+
+ coap_error_code = message_send(contextP, response, fromSessionH);
+
+ lwm2m_free(response->payload);
+ response->payload = NULL;
+ response->payload_len = 0;
+ }
+ else if (coap_error_code != COAP_IGNORE)
+ {
+ if (1 == coap_set_status_code(response, coap_error_code))
+ {
+ coap_error_code = message_send(contextP, response, fromSessionH);
+ }
+ }
+ }
+ else
+ {
+ /* Responses */
+ switch (message->type)
+ {
+ case COAP_TYPE_NON:
+ case COAP_TYPE_CON:
+ {
+ bool done = transaction_handleResponse(contextP, fromSessionH, message, response);
+
+#ifdef LWM2M_SERVER_MODE
+ if (!done && IS_OPTION(message, COAP_OPTION_OBSERVE) &&
+ ((message->code == COAP_204_CHANGED) || (message->code == COAP_205_CONTENT)))
+ {
+ done = observe_handleNotify(contextP, fromSessionH, message, response);
+ }
+#endif
+ if (!done && message->type == COAP_TYPE_CON )
+ {
+ coap_init_message(response, COAP_TYPE_ACK, 0, message->mid);
+ coap_error_code = message_send(contextP, response, fromSessionH);
+ }
+ }
+ break;
+
+ case COAP_TYPE_RST:
+ /* Cancel possible subscriptions. */
+ handle_reset(contextP, fromSessionH, message);
+ transaction_handleResponse(contextP, fromSessionH, message, NULL);
+ break;
+
+ case COAP_TYPE_ACK:
+ transaction_handleResponse(contextP, fromSessionH, message, NULL);
+ break;
+
+ default:
+ break;
+ }
+ } /* Request or Response */
+ coap_free_header(message);
+ } /* if (parsed correctly) */
+ else
+ {
+ LOG_ARG("Message parsing failed %u.%2u", coap_error_code >> 5, coap_error_code & 0x1F);
+ }
+
+ if (coap_error_code != NO_ERROR && coap_error_code != COAP_IGNORE)
+ {
+ LOG_ARG("ERROR %u: %s", coap_error_code, coap_error_message);
+
+ /* Set to sendable error code. */
+ if (coap_error_code >= 192)
+ {
+ coap_error_code = COAP_500_INTERNAL_SERVER_ERROR;
+ }
+ /* Reuse input buffer for error message. */
+ coap_init_message(message, COAP_TYPE_ACK, coap_error_code, message->mid);
+ coap_set_payload(message, coap_error_message, strlen(coap_error_message));
+ message_send(contextP, message, fromSessionH);
+ }
+}
+
+
+coap_status_t message_send(lwm2m_context_t * contextP,
+ coap_packet_t * message,
+ void * sessionH)
+{
+ coap_status_t result = COAP_500_INTERNAL_SERVER_ERROR;
+ uint8_t * pktBuffer;
+ size_t pktBufferLen = 0;
+ size_t allocLen;
+
+ LOG("Entering");
+ allocLen = coap_serialize_get_size(message);
+ LOG_ARG("Size to allocate: %d", allocLen);
+ if (allocLen == 0) return COAP_500_INTERNAL_SERVER_ERROR;
+
+ pktBuffer = (uint8_t *)lwm2m_malloc(allocLen);
+ if (pktBuffer != NULL)
+ {
+ pktBufferLen = coap_serialize_message(message, pktBuffer);
+ LOG_ARG("coap_serialize_message() returned %d", pktBufferLen);
+ if (0 != pktBufferLen)
+ {
+ result = lwm2m_buffer_send(sessionH, pktBuffer, pktBufferLen, contextP->userData);
+ }
+ lwm2m_free(pktBuffer);
+ }
+
+ return result;
+}
+