+
+
+int lwm2m_PlainTextToInt64(char * buffer,
+ int length,
+ int64_t * dataP)
+{
+ uint64_t result = 0;
+ int sign = 1;
+ int mul = 0;
+ int i = 0;
+
+ if (0 == length) return 0;
+
+ if (buffer[0] == '-')
+ {
+ sign = -1;
+ i = 1;
+ }
+
+ while (i < length)
+ {
+ if ('0' <= buffer[i] && buffer[i] <= '9')
+ {
+ if (0 == mul)
+ {
+ mul = 10;
+ }
+ else
+ {
+ result *= mul;
+ }
+ result += buffer[i] - '0';
+ }
+ else
+ {
+ return 0;
+ }
+ i++;
+ }
+
+ *dataP = result * sign;
+ return 1;
+}
+
+int lwm2m_int8ToPlainText(int8_t data,
+ char ** bufferP)
+{
+ return lwm2m_int64ToPlainText((int64_t)data, bufferP);
+}
+
+int lwm2m_int16ToPlainText(int16_t data,
+ char ** bufferP)
+{
+ return lwm2m_int64ToPlainText((int64_t)data, bufferP);
+}
+
+int lwm2m_int32ToPlainText(int32_t data,
+ char ** bufferP)
+{
+ return lwm2m_int64ToPlainText((int64_t)data, bufferP);
+}
+
+int lwm2m_int64ToPlainText(int64_t data,
+ char ** bufferP)
+{
+ char string[32];
+ int len;
+
+ len = snprintf(string, 32, "%" PRId64, data);
+ if (len > 0)
+ {
+ *bufferP = (char *)lwm2m_malloc(len);
+
+ if (NULL != *bufferP)
+ {
+ strncpy(*bufferP, string, len);
+ }
+ else
+ {
+ len = 0;
+ }
+ }
+
+ return len;
+}
+
+
+int lwm2m_float32ToPlainText(float data,
+ char ** bufferP)
+{
+ return lwm2m_float64ToPlainText((double)data, bufferP);
+}
+
+
+int lwm2m_float64ToPlainText(double data,
+ char ** bufferP)
+{
+ char string[64];
+ int len;
+
+ len = snprintf(string, 64, "%lf", data);
+ if (len > 0)
+ {
+ *bufferP = (char *)lwm2m_malloc(len);
+
+ if (NULL != *bufferP)
+ {
+ strncpy(*bufferP, string, len);
+ }
+ else
+ {
+ len = 0;
+ }
+ }
+
+ return len;
+}
+
+
+int lwm2m_boolToPlainText(bool data,
+ char ** bufferP)
+{
+ return lwm2m_int64ToPlainText((int64_t)(data?1:0), bufferP);
+}
+
diff --git a/notice.html b/notice.html
new file mode 100644
index 000000000..c3d34c3c2
--- /dev/null
+++ b/notice.html
@@ -0,0 +1,107 @@
+
+
+
+
+
+Eclipse Foundation Software User Agreement
+
+
+
+Eclipse Foundation Software User Agreement
+April 9, 2014
+
+Usage Of Content
+
+THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+ (COLLECTIVELY "CONTENT"). USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+ CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE
+ OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
+ NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
+ CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.
+
+Applicable Licenses
+
+Unless otherwise indicated, all Content made available by the Eclipse Foundation is provided to you under the terms and conditions of the Eclipse Public License Version 1.0
+ ("EPL"). A copy of the EPL is provided with this Content and is also available at http://www.eclipse.org/legal/epl-v10.html.
+ For purposes of the EPL, "Program" will mean the Content.
+
+Content includes, but is not limited to, source code, object code, documentation and other files maintained in the Eclipse Foundation source code
+ repository ("Repository") in software modules ("Modules") and made available as downloadable archives ("Downloads").
+
+
+ - Content may be structured and packaged into modules to facilitate delivering, extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"), plug-in fragments ("Fragments"), and features ("Features").
+ - Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java™ ARchive) in a directory named "plugins".
+ - A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material. Each Feature may be packaged as a sub-directory in a directory named "features". Within a Feature, files named "feature.xml" may contain a list of the names and version numbers of the Plug-ins
+ and/or Fragments associated with that Feature.
+ - Features may also include other Features ("Included Features"). Within a Feature, files named "feature.xml" may contain a list of the names and version numbers of Included Features.
+
+
+The terms and conditions governing Plug-ins and Fragments should be contained in files named "about.html" ("Abouts"). The terms and conditions governing Features and
+Included Features should be contained in files named "license.html" ("Feature Licenses"). Abouts and Feature Licenses may be located in any directory of a Download or Module
+including, but not limited to the following locations:
+
+
+ - The top-level (root) directory
+ - Plug-in and Fragment directories
+ - Inside Plug-ins and Fragments packaged as JARs
+ - Sub-directories of the directory named "src" of certain Plug-ins
+ - Feature directories
+
+
+Note: if a Feature made available by the Eclipse Foundation is installed using the Provisioning Technology (as defined below), you must agree to a license ("Feature Update License") during the
+installation process. If the Feature contains Included Features, the Feature Update License should either provide you with the terms and conditions governing the Included Features or
+inform you where you can locate them. Feature Update Licenses may be found in the "license" property of files named "feature.properties" found within a Feature.
+Such Abouts, Feature Licenses, and Feature Update Licenses contain the terms and conditions (or references to such terms and conditions) that govern your use of the associated Content in
+that directory.
+
+THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS. SOME OF THESE
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):
+
+
+
+IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License, or Feature Update License is provided, please
+contact the Eclipse Foundation to determine what terms and conditions govern that particular Content.
+
+
+Use of Provisioning Technology
+
+The Eclipse Foundation makes available provisioning software, examples of which include, but are not limited to, p2 and the Eclipse
+ Update Manager ("Provisioning Technology") for the purpose of allowing users to install software, documentation, information and/or
+ other materials (collectively "Installable Software"). This capability is provided with the intent of allowing such users to
+ install, extend and update Eclipse-based products. Information about packaging Installable Software is available at http://eclipse.org/equinox/p2/repository_packaging.html
+ ("Specification").
+
+You may use Provisioning Technology to allow other parties to install Installable Software. You shall be responsible for enabling the
+ applicable license agreements relating to the Installable Software to be presented to, and accepted by, the users of the Provisioning Technology
+ in accordance with the Specification. By using Provisioning Technology in such a manner and making it available in accordance with the
+ Specification, you further acknowledge your agreement to, and the acquisition of all necessary rights to permit the following:
+
+
+ - A series of actions may occur ("Provisioning Process") in which a user may execute the Provisioning Technology
+ on a machine ("Target Machine") with the intent of installing, extending or updating the functionality of an Eclipse-based
+ product.
+ - During the Provisioning Process, the Provisioning Technology may cause third party Installable Software or a portion thereof to be
+ accessed and copied to the Target Machine.
+ - Pursuant to the Specification, you will provide to the user the terms and conditions that govern the use of the Installable
+ Software ("Installable Software Agreement") and such Installable Software Agreement shall be accessed from the Target
+ Machine in accordance with the Specification. Such Installable Software Agreement must inform the user of the terms and conditions that govern
+ the Installable Software and must solicit acceptance by the end user in the manner prescribed in such Installable Software Agreement. Upon such
+ indication of agreement by the user, the provisioning Technology will complete installation of the Installable Software.
+
+
+Cryptography
+
+Content may contain encryption software. The country in which you are currently may have restrictions on the import, possession, and use, and/or re-export to
+ another country, of encryption software. BEFORE using any encryption software, please check the country's laws, regulations and policies concerning the import,
+ possession, or use, and re-export of encryption software, to see if this is permitted.
+
+Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.
+
+
diff --git a/tests/TLV/CMakeLists.txt b/tests/TLV/CMakeLists.txt
new file mode 100644
index 000000000..94b2a0d76
--- /dev/null
+++ b/tests/TLV/CMakeLists.txt
@@ -0,0 +1,10 @@
+cmake_minimum_required (VERSION 2.6)
+
+project (tlvdecode)
+
+include_directories ("${PROJECT_SOURCE_DIR}/../..")
+
+SET(SOURCES decode.c)
+SET(CORE_SOURCES ${PROJECT_SOURCE_DIR}/../../core/tlv.c)
+
+add_executable(tlvdecode ${SOURCES} ${CORE_SOURCES})
diff --git a/tests/TLV/decode.c b/tests/TLV/decode.c
new file mode 100644
index 000000000..b5f4243cd
--- /dev/null
+++ b/tests/TLV/decode.c
@@ -0,0 +1,244 @@
+/*******************************************************************************
+ *
+ * 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
+ *
+ *******************************************************************************/
+
+#include "core/liblwm2m.h"
+
+#include
+#include
+#include
+#include
+
+static void prv_output_buffer(uint8_t * buffer,
+ int length)
+{
+ int i;
+ uint8_t array[16];
+
+ if (length == 0 || length > 16) printf("\n");
+
+ i = 0;
+ while (i < length)
+ {
+ int j;
+ printf(" ");
+
+ memcpy(array, buffer+i, 16);
+
+ for (j = 0 ; j < 16 && i+j < length; j++)
+ {
+ printf("%02X ", array[j]);
+ }
+ if (length > 16)
+ {
+ while (j < 16)
+ {
+ printf(" ");
+ j++;
+ }
+ }
+ printf(" ");
+ for (j = 0 ; j < 16 && i+j < length; j++)
+ {
+ if (isprint(array[j]))
+ printf("%c ", array[j]);
+ else
+ printf(". ");
+ }
+ printf("\n");
+
+ i += 16;
+ }
+}
+
+void print_indent(int num)
+{
+ int i;
+
+ for ( i = 0 ; i< num ; i++)
+ printf("\t");
+}
+
+void dump_tlv(int size,
+ lwm2m_tlv_t * tlvP,
+ int indent)
+{
+ int i;
+
+ for(i= 0 ; i < size ; i++)
+ {
+ print_indent(indent);
+ printf("type: ");
+ switch (tlvP[i].type)
+ {
+ case LWM2M_TYPE_OBJECT_INSTANCE:
+ printf("TLV_OBJECT_INSTANCE\r\n");
+ break;
+ case LWM2M_TYPE_RESSOURCE_INSTANCE:
+ printf("TLV_RESSOURCE_INSTANCE\r\n");
+ break;
+ case LWM2M_TYPE_MULTIPLE_RESSOURCE:
+ printf("TLV_MULTIPLE_INSTANCE\r\n");
+ break;
+ case LWM2M_TYPE_RESSOURCE:
+ printf("TLV_RESSOURCE\r\n");
+ break;
+ default:
+ printf("unknown (%d)\r\n", (int)tlvP[i].type);
+ break;
+ }
+ print_indent(indent);
+ printf("id: %d\r\n", tlvP[i].id);
+ print_indent(indent);
+ printf("data (%d bytes): ", tlvP[i].length);
+ prv_output_buffer(tlvP[i].value, tlvP[i].length);
+ if (tlvP[i].type == LWM2M_TYPE_OBJECT_INSTANCE
+ || tlvP[i].type == LWM2M_TYPE_MULTIPLE_RESSOURCE)
+ {
+ dump_tlv(tlvP[i].length, (lwm2m_tlv_t *)(tlvP[i].value), indent+1);
+ }
+ else if (tlvP[i].length <= 8)
+ {
+ int64_t value;
+ if (0 != lwm2m_opaqueToInt(tlvP[i].value, tlvP[i].length, &value))
+ {
+ print_indent(indent);
+ printf(" as int: %ld\r\n", value);
+ }
+ }
+ }
+}
+
+void decode(char * buffer,
+ size_t buffer_len,
+ int indent)
+{
+ lwm2m_tlv_type_t type;
+ uint16_t id;
+ size_t dataIndex;
+ size_t dataLen;
+ int length = 0;
+ int result;
+
+ while (0 != (result = lwm2m_decodeTLV(buffer + length, buffer_len - length, &type, &id, &dataIndex, &dataLen)))
+ {
+ print_indent(indent);
+ printf("type: ");
+ switch (type)
+ {
+ case TLV_OBJECT_INSTANCE:
+ printf("TLV_OBJECT_INSTANCE\r\n");
+ break;
+ case TLV_RESSOURCE_INSTANCE:
+ printf("TLV_RESSOURCE_INSTANCE\r\n");
+ break;
+ case TLV_MULTIPLE_INSTANCE:
+ printf("TLV_MULTIPLE_INSTANCE\r\n");
+ break;
+ case TLV_RESSOURCE:
+ printf("TLV_RESSOURCE\r\n");
+ break;
+ default:
+ printf("unknown (%d)\r\n", (int)type);
+ break;
+ }
+ print_indent(indent);
+ printf("id: %d\r\n", id);
+ print_indent(indent);
+ printf("data (%d bytes): ", dataLen);
+ prv_output_buffer(buffer + length + dataIndex, dataLen);
+ if (type == TLV_OBJECT_INSTANCE || type == TLV_MULTIPLE_INSTANCE)
+ {
+ decode(buffer + length + dataIndex, dataLen, indent+1);
+ }
+ else if (dataLen <= 8)
+ {
+ int64_t value;
+ if (0 != lwm2m_opaqueToInt(buffer + length + dataIndex, dataLen, &value))
+ {
+ print_indent(indent);
+ printf(" as int: %ld\r\n", value);
+ }
+ }
+
+ length += result;
+ }
+}
+
+int main(int argc, char *argv[])
+{
+ lwm2m_tlv_t * tlvP;
+ int size;
+ int length;
+ char * buffer;
+
+ char buffer1[] = {0x03, 0x0A, 0xC1, 0x01, 0x14, 0x03, 0x0B, 0xC1, 0x01, 0x15, 0x03, 0x0C, 0xC1, 0x01, 0x16};
+ char buffer2[] = {0xC8, 0x00, 0x14, 0x4F, 0x70, 0x65, 0x6E, 0x20, 0x4D, 0x6F, 0x62, 0x69, 0x6C, 0x65, 0x20,
+ 0x41, 0x6C, 0x6C, 0x69, 0x61, 0x6E, 0x63, 0x65, 0xC8, 0x01, 0x16, 0x4C, 0x69, 0x67, 0x68,
+ 0x74, 0x77 , 0x65, 0x69, 0x67, 0x68, 0x74, 0x20, 0x4D, 0x32, 0x4D, 0x20, 0x43, 0x6C, 0x69,
+ 0x65, 0x6E, 0x74 , 0xC8, 0x02, 0x09, 0x33, 0x34, 0x35, 0x30, 0x30, 0x30, 0x31, 0x32, 0x33,
+ 0xC3, 0x03, 0x31, 0x2E , 0x30, 0x86, 0x06, 0x41, 0x00, 0x01, 0x41, 0x01, 0x05, 0x88, 0x07,
+ 0x08, 0x42, 0x00, 0x0E, 0xD8 , 0x42, 0x01, 0x13, 0x88, 0x87, 0x08, 0x41, 0x00, 0x7D, 0x42,
+ 0x01, 0x03, 0x84, 0xC1, 0x09, 0x64 , 0xC1, 0x0A, 0x0F, 0x83, 0x0B, 0x41, 0x00, 0x00, 0xC4,
+ 0x0D, 0x51, 0x82, 0x42, 0x8F, 0xC6, 0x0E, 0x2B, 0x30, 0x32, 0x3A, 0x30, 0x30, 0xC1, 0x0F, 0x55};
+
+ printf("Buffer 1:\n");
+ decode(buffer1, sizeof(buffer1), 0);
+ printf("\n\nBuffer 1 using lwm2m_tlv_t:\n");
+ size = lwm2m_tlv_parse(buffer1, sizeof(buffer1), &tlvP);
+ dump_tlv(size, tlvP, 0);
+ length = lwm2m_tlv_serialize(size, tlvP, &buffer);
+ if (length != sizeof(buffer1))
+ {
+ printf("\n\nSerialize Buffer 1 failed: %d bytes instead of %d\n", length, sizeof(buffer1));
+ }
+ else if (memcmp(buffer, buffer1, length) != 0)
+ {
+ printf("\n\nSerialize Buffer 1 failed:\n");
+ prv_output_buffer(buffer, length);
+ printf("\ninstead of:\n");
+ prv_output_buffer(buffer1, length);
+ }
+ else
+ {
+ printf("\n\nSerialize Buffer 1 OK\n");
+ }
+ lwm2m_tlv_free(size, tlvP);
+
+ printf("\n\n============\n\nBuffer 2: \r\r\n");
+ decode(buffer2, sizeof(buffer2), 0);
+ printf("\n\nBuffer 2 using lwm2m_tlv_t: \r\r\n");
+ size = lwm2m_tlv_parse(buffer2, sizeof(buffer2), &tlvP);
+ dump_tlv(size, tlvP, 0);
+ length = lwm2m_tlv_serialize(size, tlvP, &buffer);
+ if (length != sizeof(buffer2))
+ {
+ printf("\n\nSerialize Buffer 2 failed: %d bytes instead of %d\n", length, sizeof(buffer2));
+ }
+ else if (memcmp(buffer, buffer2, length) != 0)
+ {
+ printf("\n\nSerialize Buffer 2 failed:\n");
+ prv_output_buffer(buffer, length);
+ printf("\ninstead of:\n");
+ prv_output_buffer(buffer2, length);
+ }
+ else
+ {
+ printf("\n\nSerialize Buffer 2 OK\n\n");
+ }
+ lwm2m_tlv_free(size, tlvP);
+}
+
diff --git a/tests/client/CMakeLists.txt b/tests/client/CMakeLists.txt
new file mode 100644
index 000000000..acb485851
--- /dev/null
+++ b/tests/client/CMakeLists.txt
@@ -0,0 +1,15 @@
+cmake_minimum_required (VERSION 2.8.3)
+
+project (lwm2mclient)
+
+SET(LIBLWM2M_DIR ${PROJECT_SOURCE_DIR}/../../core)
+
+add_definitions(-DLWM2M_CLIENT_MODE)
+
+include_directories (${LIBLWM2M_DIR} ${PROJECT_SOURCE_DIR}/../utils)
+
+add_subdirectory(${LIBLWM2M_DIR} ${CMAKE_CURRENT_BINARY_DIR}/core)
+
+SET(SOURCES lwm2mclient.c ../utils/commandline.c ../utils/connection.c object_device.c object_firmware.c test_object.c)
+
+add_executable(lwm2mclient ${SOURCES} ${CORE_SOURCES})
diff --git a/tests/client/lwm2mclient.c b/tests/client/lwm2mclient.c
new file mode 100644
index 000000000..6556f0f26
--- /dev/null
+++ b/tests/client/lwm2mclient.c
@@ -0,0 +1,483 @@
+/*******************************************************************************
+ *
+ * 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
+ * Benjamin Cabé - Please refer to git log
+ * Fabien Fleutot - Please refer to git log
+ * Simon Bernard - Please refer to git log
+ * Julien Vermillard - Please refer to git log
+ * Axel Lorente - Please refer to git log
+ * Toby Jaffey - 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
+
+*/
+
+
+#include "liblwm2m.h"
+#include "commandline.h"
+#include "connection.h"
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#define MAX_PACKET_SIZE 128
+
+static int g_quit = 0;
+
+extern lwm2m_object_t * get_object_device();
+extern lwm2m_object_t * get_object_firmware();
+extern lwm2m_object_t * get_test_object();
+
+static void prv_quit(char * buffer,
+ void * user_data)
+{
+ g_quit = 1;
+}
+
+void handle_sigint(int signum)
+{
+ g_quit = 2;
+}
+
+void print_usage(void)
+{
+ fprintf(stderr, "Usage: lwm2mclient\r\n");
+ fprintf(stderr, "Launch a LWM2M client.\r\n\n");
+}
+
+static uint8_t prv_buffer_send(void * sessionH,
+ uint8_t * buffer,
+ size_t length,
+ void * userdata)
+{
+ connection_t * connP = (connection_t*) sessionH;
+
+ if (-1 == connection_send(connP, buffer, length))
+ {
+ return COAP_500_INTERNAL_SERVER_ERROR;
+ }
+ return COAP_NO_ERROR;
+}
+
+static void prv_output_servers(char * buffer,
+ void * user_data)
+{
+ lwm2m_context_t * lwm2mH = (lwm2m_context_t *) user_data;
+ lwm2m_server_t * targetP;
+
+ targetP = lwm2mH->serverList;
+
+ if (targetP == NULL)
+ {
+ fprintf(stdout, "No server.\r\n");
+ return;
+ }
+
+ for (targetP = lwm2mH->serverList ; targetP != NULL ; targetP = targetP->next)
+ {
+ fprintf(stdout, "Server ID %d:\r\n", targetP->shortID);
+ fprintf(stdout, "\tstatus: ");
+ switch(targetP->status)
+ {
+ case STATE_UNKNOWN:
+ fprintf(stdout, "UNKNOWN\r\n");
+ break;
+ case STATE_REG_PENDING:
+ fprintf(stdout, "REGISTRATION PENDING\r\n");
+ break;
+ case STATE_REGISTERED:
+ fprintf(stdout, "REGISTERED location: \"%s\"\r\n", targetP->location);
+ break;
+ }
+ fprintf(stdout, "\r\n");
+ }
+}
+
+static void prv_change(char * buffer,
+ void * user_data)
+{
+ lwm2m_context_t * lwm2mH = (lwm2m_context_t *) user_data;
+ lwm2m_uri_t uri;
+ int result;
+ size_t length;
+
+ if (buffer[0] == 0) goto syntax_error;
+
+ length = 0;
+ // remove white space
+ while (length < strlen(buffer) && isspace(buffer[length]))
+ {
+ length++;
+ }
+ // find end of URI
+ while (length < strlen(buffer) && !isspace(buffer[length]))
+ {
+ length++;
+ }
+
+ result = lwm2m_stringToUri(buffer, length, &uri);
+ if (result == 0) goto syntax_error;
+
+ buffer += length;
+ while (buffer[0] != 0 && isspace(buffer[0])) buffer++;
+ if (buffer[0] == 0)
+ {
+ lwm2m_resource_value_changed(lwm2mH, &uri);
+ }
+ else
+ {
+ int i;
+
+ i = 0;
+ while (i < lwm2mH->numObject)
+ {
+ if (uri.objectId == lwm2mH->objectList[i]->objID)
+ {
+ if (lwm2mH->objectList[i]->writeFunc != NULL)
+ {
+ lwm2m_tlv_t * tlvP;
+
+ tlvP = lwm2m_tlv_new(1);
+ if (tlvP == NULL)
+ {
+ fprintf(stdout, "Internal allocation failure !\n");
+ return;
+ }
+ tlvP->flags = LWM2M_TLV_FLAG_STATIC_DATA | LWM2M_TLV_FLAG_TEXT_FORMAT;
+ tlvP->id = uri.resourceId;
+ tlvP->length = strlen(buffer);
+ tlvP->value = buffer;
+
+ if (COAP_204_CHANGED != lwm2mH->objectList[i]->writeFunc(uri.instanceId,
+ 1, tlvP,
+ lwm2mH->objectList[i]))
+ {
+ fprintf(stdout, "Failed to change value !\n");
+ }
+ else
+ {
+ lwm2m_resource_value_changed(lwm2mH, &uri);
+ }
+ lwm2m_tlv_free(1, tlvP);
+ return;
+ }
+ return;
+ }
+ i++;
+ }
+
+ fprintf(stdout, "Object not found !\n");
+ }
+ return;
+
+syntax_error:
+ fprintf(stdout, "Syntax error !\n");
+}
+
+int main(int argc, char *argv[])
+{
+ int sock;
+ int result;
+ lwm2m_context_t * lwm2mH = NULL;
+ lwm2m_object_t * objArray[3];
+ lwm2m_security_t security;
+ int i;
+ connection_t * connList;
+
+ connList = NULL;
+
+ /*
+ * The function start by setting up the command line interface (which may or not be useful depending on your project)
+ *
+ * This is an array of commands describes as { name, description, long description, callback, userdata }.
+ * The firsts tree are easy to understand, the callback is the function that will be called when this command is typed
+ * and in the last one will be stored the lwm2m context (allowing access to the server settings and the objects).
+ */
+ command_desc_t commands[] =
+ {
+ {"list", "List known servers.", NULL, prv_output_servers, NULL},
+ {"change", "Change the value of resource.", " change URI [DATA]\r\n"
+ " URI: uri of the resource such as /3/0, /3/0/2\r\n"
+ " DATA: (optional) new value\r\n", prv_change, NULL},
+ {"quit", "Quit the client gracefully.", NULL, prv_quit, NULL},
+ {"^C", "Quit the client abruptly (without sending a de-register message).", NULL, NULL, NULL},
+
+ COMMAND_END_LIST
+ };
+
+ /*
+ *This call an internal function that create an IPV6 socket on the port 5683.
+ */
+ sock = create_socket("5683");
+ if (sock < 0)
+ {
+ fprintf(stderr, "Failed to open socket: %d\r\n", errno);
+ return -1;
+ }
+
+ /*
+ * Now the main function fill an array with each object, this list will be later passed to liblwm2m.
+ * Those functions are located in their respective object file.
+ */
+ objArray[0] = get_object_device();
+ if (NULL == objArray[0])
+ {
+ fprintf(stderr, "Failed to create Device object\r\n");
+ return -1;
+ }
+
+ objArray[1] = get_object_firmware();
+ if (NULL == objArray[1])
+ {
+ fprintf(stderr, "Failed to create Firmware object\r\n");
+ return -1;
+ }
+
+ objArray[2] = get_test_object();
+ if (NULL == objArray[2])
+ {
+ fprintf(stderr, "Failed to create test object\r\n");
+ return -1;
+ }
+
+ /*
+ * The liblwm2m library is now initialized with the name of the client - which shall be unique for each client -
+ * the number of objects we will be passing through, the object constructor array and the function that will be in
+ * charge to send the buffer (containing the LWM2M packets) to the network
+ */
+ lwm2mH = lwm2m_init("testlwm2mclient", 3, objArray, prv_buffer_send, NULL);
+ if (NULL == lwm2mH)
+ {
+ fprintf(stderr, "lwm2m_init() failed\r\n");
+ return -1;
+ }
+
+ signal(SIGINT, handle_sigint);
+
+ connList = connection_create(connList, sock, "localhost", LWM2M_STANDARD_PORT);
+ if (connList == NULL)
+ {
+ fprintf(stderr, "Connection creation failed.\r\n");
+ return -1;
+ }
+
+ memset(&security, 0, sizeof(lwm2m_security_t));
+
+ /*
+ * This function add a server to the lwm2m context by passing an identifier, an opaque connection handler and a security
+ * context.
+ * You can add as many server as your application need and there will be thereby allowed to interact with your object
+ */
+ result = lwm2m_add_server(lwm2mH, 123, (void *)connList, &security);
+ if (result != 0)
+ {
+ fprintf(stderr, "lwm2m_add_server() failed: 0x%X\r\n", result);
+ return -1;
+ }
+
+ /*
+ * This function register your client to all the servers you added with the precedent one
+ */
+ result = lwm2m_register(lwm2mH);
+ if (result != 0)
+ {
+ fprintf(stderr, "lwm2m_register() failed: 0x%X\r\n", result);
+ return -1;
+ }
+
+ /*
+ * As you now have your lwm2m context complete you can pass it as an argument to all the command line functions
+ * precedently viewed (first point)
+ */
+ for (i = 0 ; commands[i].name != NULL ; i++)
+ {
+ commands[i].userData = (void *)lwm2mH;
+ }
+ fprintf(stdout, "> "); fflush(stdout);
+
+ /*
+ * We now enter in a while loop that will handle the communications from the server
+ */
+ while (0 == g_quit)
+ {
+ struct timeval tv;
+ fd_set readfds;
+
+ FD_ZERO(&readfds);
+ FD_SET(sock, &readfds);
+ FD_SET(STDIN_FILENO, &readfds);
+
+ tv.tv_sec = 60;
+ tv.tv_usec = 0;
+
+ /*
+ * This function does two things:
+ * - first it does the work needed by liblwm2m (eg. (re)sending some packets).
+ * - Secondly it adjust the timeout value (default 60s) depending on the state of the transaction
+ * (eg. retransmission) and the time between the next operation
+ */
+ result = lwm2m_step(lwm2mH, &tv);
+ if (result != 0)
+ {
+ fprintf(stderr, "lwm2m_step() failed: 0x%X\r\n", result);
+ return -1;
+ }
+
+ /*
+ * This part will set up an interruption until an event happen on SDTIN or the socket until "tv" timed out (set
+ * with the precedent function)
+ */
+ result = select(FD_SETSIZE, &readfds, NULL, NULL, &tv);
+
+ if ( result < 0 )
+ {
+ if (errno != EINTR)
+ {
+ fprintf(stderr, "Error in select(): %d\r\n", errno);
+ }
+ }
+ else if (result > 0)
+ {
+ uint8_t buffer[MAX_PACKET_SIZE];
+ int numBytes;
+
+ /*
+ * If an event happen on the socket
+ */
+ if (FD_ISSET(sock, &readfds))
+ {
+ struct sockaddr_storage addr;
+ socklen_t addrLen;
+
+ addrLen = sizeof(addr);
+
+ /*
+ * We retrieve the data received
+ */
+ numBytes = recvfrom(sock, buffer, MAX_PACKET_SIZE, 0, (struct sockaddr *)&addr, &addrLen);
+
+ if (numBytes == -1)
+ {
+ fprintf(stderr, "Error in recvfrom(): %d\r\n", errno);
+ }
+ else
+ {
+ char s[INET6_ADDRSTRLEN];
+ connection_t * connP;
+
+ fprintf(stderr, "%d bytes received from [%s]:%hu\r\n",
+ numBytes,
+ inet_ntop(addr.ss_family,
+ &(((struct sockaddr_in6*)&addr)->sin6_addr),
+ s,
+ INET6_ADDRSTRLEN),
+ ntohs(((struct sockaddr_in6*)&addr)->sin6_port));
+
+ /*
+ * Display it in the STDERR
+ */
+ output_buffer(stderr, buffer, numBytes);
+
+ connP = connection_find(connList, &addr, addrLen);
+ if (connP != NULL)
+ {
+ /*
+ * Let liblwm2m respond to the query depending on the context
+ */
+ lwm2m_handle_packet(lwm2mH, buffer, numBytes, connP);
+ }
+ }
+ }
+
+ /*
+ * If the event happened on the SDTIN
+ */
+ else if (FD_ISSET(STDIN_FILENO, &readfds))
+ {
+ numBytes = read(STDIN_FILENO, buffer, MAX_PACKET_SIZE);
+
+ if (numBytes > 1)
+ {
+ buffer[numBytes - 1] = 0;
+
+ /*
+ * We call the corresponding callback of the typed command passing it the buffer for further arguments
+ */
+ handle_command(commands, buffer);
+ }
+ if (g_quit == 0)
+ {
+ fprintf(stdout, "\r\n> ");
+ fflush(stdout);
+ }
+ else
+ {
+ fprintf(stdout, "\r\n");
+ }
+ }
+ }
+ }
+
+ /*
+ * Finally when the loop is left smoothly - asked by user in the command line interface - we unregister our client from it
+ */
+ if (g_quit == 1)
+ {
+ lwm2m_close(lwm2mH);
+ }
+ close(sock);
+ connection_free(connList);
+
+ return 0;
+}
diff --git a/tests/client/object_device.c b/tests/client/object_device.c
new file mode 100644
index 000000000..08042c603
--- /dev/null
+++ b/tests/client/object_device.c
@@ -0,0 +1,490 @@
+/*******************************************************************************
+ *
+ * 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
+ * Axel Lorente - 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
+
+*/
+
+/*
+ * This object is single instance only, and is mandatory to all LWM2M device as it describe the object such as its
+ * manufacturer, model, etc...
+ */
+
+#include "liblwm2m.h"
+
+#include
+#include
+#include
+#include
+
+
+#define PRV_MANUFACTURER "Open Mobile Alliance"
+#define PRV_MODEL_NUMBER "Lightweight M2M Client"
+#define PRV_SERIAL_NUMBER "345000123"
+#define PRV_FIRMWARE_VERSION "1.0"
+#define PRV_POWER_SOURCE_1 1
+#define PRV_POWER_SOURCE_2 5
+#define PRV_POWER_VOLTAGE_1 3800
+#define PRV_POWER_VOLTAGE_2 5000
+#define PRV_POWER_CURRENT_1 125
+#define PRV_POWER_CURRENT_2 900
+#define PRV_BATTERY_LEVEL 100
+#define PRV_MEMORY_FREE 15
+#define PRV_ERROR_CODE 0
+#define PRV_BINDING_MODE "U"
+
+#define PRV_OFFSET_MAXLEN 7 //+HH:MM\0 at max
+#define PRV_TLV_BUFFER_SIZE 128
+
+typedef struct
+{
+ int64_t time;
+ char time_offset[PRV_OFFSET_MAXLEN];
+} device_data_t;
+
+
+// basic check that the time offset value is at ISO 8601 format
+// bug: +12:30 is considered a valid value by this function
+static int prv_check_time_offset(char * buffer,
+ int length)
+{
+ int min_index;
+
+ if (length != 3 && length != 5 && length != 6) return 0;
+ if (buffer[0] != '-' && buffer[0] != '+') return 0;
+ switch (buffer[1])
+ {
+ case '0':
+ if (buffer[2] < '0' || buffer[2] > '9') return 0;
+ break;
+ case '1':
+ if (buffer[2] < '0' || buffer[2] > '2') return 0;
+ break;
+ default:
+ return 0;
+ }
+ switch (length)
+ {
+ case 3:
+ return 1;
+ case 5:
+ min_index = 3;
+ break;
+ case 6:
+ if (buffer[3] != ':') return 0;
+ min_index = 4;
+ break;
+ default:
+ // never happen
+ return 0;
+ }
+ if (buffer[min_index] < '0' || buffer[min_index] > '5') return 0;
+ if (buffer[min_index+1] < '0' || buffer[min_index+1] > '9') return 0;
+
+ return 1;
+}
+
+static uint8_t prv_set_value(lwm2m_tlv_t * tlvP,
+ device_data_t * devDataP)
+{
+ // a simple switch structure is used to respond at the specified resource asked
+ switch (tlvP->id)
+ {
+ case 0:
+ tlvP->value = PRV_MANUFACTURER;
+ tlvP->length = strlen(PRV_MANUFACTURER);
+ tlvP->flags = LWM2M_TLV_FLAG_STATIC_DATA;
+ tlvP->type = LWM2M_TYPE_RESSOURCE;
+ return COAP_205_CONTENT;
+
+ case 1:
+ tlvP->value = PRV_MODEL_NUMBER;
+ tlvP->length = strlen(PRV_MODEL_NUMBER);
+ tlvP->flags = LWM2M_TLV_FLAG_STATIC_DATA;
+ tlvP->type = LWM2M_TYPE_RESSOURCE;
+ return COAP_205_CONTENT;
+
+ case 2:
+ tlvP->value = PRV_SERIAL_NUMBER;
+ tlvP->length = strlen(PRV_SERIAL_NUMBER);
+ tlvP->flags = LWM2M_TLV_FLAG_STATIC_DATA;
+ tlvP->type = LWM2M_TYPE_RESSOURCE;
+ return COAP_205_CONTENT;
+
+ case 3:
+ tlvP->value = PRV_FIRMWARE_VERSION;
+ tlvP->length = strlen(PRV_FIRMWARE_VERSION);
+ tlvP->flags = LWM2M_TLV_FLAG_STATIC_DATA;
+ tlvP->type = LWM2M_TYPE_RESSOURCE;
+ return COAP_205_CONTENT;
+
+ case 4:
+ return COAP_405_METHOD_NOT_ALLOWED;
+
+ case 5:
+ return COAP_405_METHOD_NOT_ALLOWED;
+
+ case 6:
+ {
+ lwm2m_tlv_t * subTlvP;
+
+ subTlvP = lwm2m_tlv_new(2);
+
+ subTlvP[0].flags = 0;
+ subTlvP[0].id = 0;
+ subTlvP[0].type = LWM2M_TYPE_RESSOURCE_INSTANCE;
+ lwm2m_tlv_encode_int(PRV_POWER_SOURCE_1, subTlvP);
+ if (0 == subTlvP[0].length)
+ {
+ lwm2m_tlv_free(2, subTlvP);
+ return COAP_500_INTERNAL_SERVER_ERROR;
+ }
+
+ subTlvP[1].flags = 0;
+ subTlvP[1].id = 1;
+ subTlvP[1].type = LWM2M_TYPE_RESSOURCE_INSTANCE;
+ lwm2m_tlv_encode_int(PRV_POWER_SOURCE_2, subTlvP + 1);
+ if (0 == subTlvP[1].length)
+ {
+ lwm2m_tlv_free(2, subTlvP);
+ return COAP_500_INTERNAL_SERVER_ERROR;
+ }
+
+ tlvP->flags = 0;
+ tlvP->type = LWM2M_TYPE_MULTIPLE_RESSOURCE;
+ tlvP->length = 2;
+ tlvP->value = (uint8_t *)subTlvP;
+
+ return COAP_205_CONTENT;
+ }
+
+ case 7:
+ {
+ lwm2m_tlv_t * subTlvP;
+
+ subTlvP = lwm2m_tlv_new(2);
+
+ subTlvP[0].flags = 0;
+ subTlvP[0].id = 0;
+ subTlvP[0].type = LWM2M_TYPE_RESSOURCE_INSTANCE;
+ lwm2m_tlv_encode_int(PRV_POWER_VOLTAGE_1, subTlvP);
+ if (0 == subTlvP[0].length)
+ {
+ lwm2m_tlv_free(2, subTlvP);
+ return COAP_500_INTERNAL_SERVER_ERROR;
+ }
+
+ subTlvP[1].flags = 0;
+ subTlvP[1].id = 1;
+ subTlvP[1].type = LWM2M_TYPE_RESSOURCE_INSTANCE;
+ lwm2m_tlv_encode_int(PRV_POWER_VOLTAGE_2, subTlvP + 1);
+ if (0 == subTlvP[1].length)
+ {
+ lwm2m_tlv_free(2, subTlvP);
+ return COAP_500_INTERNAL_SERVER_ERROR;
+ }
+
+ tlvP->flags = 0;
+ tlvP->type = LWM2M_TYPE_MULTIPLE_RESSOURCE;
+ tlvP->length = 2;
+ tlvP->value = (uint8_t *)subTlvP;
+
+ return COAP_205_CONTENT;
+ }
+
+ case 8:
+ {
+ lwm2m_tlv_t * subTlvP;
+
+ subTlvP = lwm2m_tlv_new(2);
+
+ subTlvP[0].flags = 0;
+ subTlvP[0].id = 0;
+ subTlvP[0].type = LWM2M_TYPE_RESSOURCE_INSTANCE;
+ lwm2m_tlv_encode_int(PRV_POWER_CURRENT_1, subTlvP);
+ if (0 == subTlvP[0].length)
+ {
+ lwm2m_tlv_free(2, subTlvP);
+ return COAP_500_INTERNAL_SERVER_ERROR;
+ }
+
+ subTlvP[1].flags = 0;
+ subTlvP[1].id = 1;
+ subTlvP[1].type = LWM2M_TYPE_RESSOURCE_INSTANCE;
+ lwm2m_tlv_encode_int(PRV_POWER_CURRENT_2, subTlvP + 1);
+ if (0 == subTlvP[1].length)
+ {
+ lwm2m_tlv_free(2, subTlvP);
+ return COAP_500_INTERNAL_SERVER_ERROR;
+ }
+
+ tlvP->flags = 0;
+ tlvP->type = LWM2M_TYPE_MULTIPLE_RESSOURCE;
+ tlvP->length = 2;
+ tlvP->value = (uint8_t *)subTlvP;
+
+ return COAP_205_CONTENT;
+ }
+
+ case 9:
+ lwm2m_tlv_encode_int(PRV_BATTERY_LEVEL, tlvP);
+ tlvP->type = LWM2M_TYPE_RESSOURCE;
+
+ if (0 != tlvP->length) return COAP_205_CONTENT;
+ else return COAP_500_INTERNAL_SERVER_ERROR;
+
+ case 10:
+ lwm2m_tlv_encode_int(PRV_MEMORY_FREE, tlvP);
+ tlvP->type = LWM2M_TYPE_RESSOURCE;
+
+ if (0 != tlvP->length) return COAP_205_CONTENT;
+ else return COAP_500_INTERNAL_SERVER_ERROR;
+
+ case 11:
+ lwm2m_tlv_encode_int(PRV_ERROR_CODE, tlvP);
+ tlvP->type = LWM2M_TYPE_RESSOURCE;
+
+ if (0 != tlvP->length) return COAP_205_CONTENT;
+ else return COAP_500_INTERNAL_SERVER_ERROR;
+
+ case 12:
+ return COAP_405_METHOD_NOT_ALLOWED;
+
+ case 13:
+ lwm2m_tlv_encode_int(devDataP->time, tlvP);
+ tlvP->type = LWM2M_TYPE_RESSOURCE;
+
+ if (0 != tlvP->length) return COAP_205_CONTENT;
+ else return COAP_500_INTERNAL_SERVER_ERROR;
+
+ case 14:
+ tlvP->value = devDataP->time_offset;
+ tlvP->length = strlen(devDataP->time_offset);
+ tlvP->flags = LWM2M_TLV_FLAG_STATIC_DATA;
+ tlvP->type = LWM2M_TYPE_RESSOURCE;
+ return COAP_205_CONTENT;
+
+ case 15:
+ tlvP->value = PRV_BINDING_MODE;
+ tlvP->length = strlen(PRV_BINDING_MODE);
+ tlvP->flags = LWM2M_TLV_FLAG_STATIC_DATA;
+ tlvP->type = LWM2M_TYPE_RESSOURCE;
+ return COAP_205_CONTENT;
+
+ default:
+ return COAP_404_NOT_FOUND;
+ }
+}
+
+static uint8_t prv_device_read(uint16_t instanceId,
+ int * numDataP,
+ lwm2m_tlv_t ** dataArrayP,
+ lwm2m_object_t * objectP)
+{
+ uint8_t result;
+ int i;
+
+ // this is a single instance object
+ if (instanceId != 0)
+ {
+ return COAP_404_NOT_FOUND;
+ }
+
+ // is the server asking for the full object ?
+ if (*numDataP == 0)
+ {
+ uint16_t resList[] = {0, 1, 2, 3, 6, 7, 8, 9, 10, 11, 13, 14, 15};
+ int nbRes = sizeof(resList)/sizeof(uint16_t);
+
+ *dataArrayP = lwm2m_tlv_new(nbRes);
+ if (*dataArrayP == NULL) return COAP_500_INTERNAL_SERVER_ERROR;
+ *numDataP = nbRes;
+ for (i = 0 ; i < nbRes ; i++)
+ {
+ (*dataArrayP)[i].id = resList[i];
+ }
+ }
+
+ i = 0;
+ do
+ {
+ result = prv_set_value((*dataArrayP) + i, (device_data_t*)(objectP->userData));
+ i++;
+ } while (i < *numDataP && result == COAP_205_CONTENT);
+
+ return result;
+}
+
+static uint8_t prv_device_write(uint16_t instanceId,
+ int numData,
+ lwm2m_tlv_t * dataArray,
+ lwm2m_object_t * objectP)
+{
+ int i;
+ uint8_t result;
+
+ // this is a single instance object
+ if (instanceId != 0)
+ {
+ return COAP_404_NOT_FOUND;
+ }
+
+ i = 0;
+
+ do
+ {
+ switch (dataArray[i].id)
+ {
+ case 13:
+ if (1 == lwm2m_tlv_decode_int(dataArray + i, &((device_data_t*)(objectP->userData))->time))
+ {
+ result = COAP_204_CHANGED;
+ }
+ else
+ {
+ result = COAP_400_BAD_REQUEST;
+ }
+ break;
+
+ case 14:
+ if (1 == prv_check_time_offset(dataArray[i].value, dataArray[i].length))
+ {
+ strncpy(((device_data_t*)(objectP->userData))->time_offset, dataArray[i].value, dataArray[i].length);
+ ((device_data_t*)(objectP->userData))->time_offset[dataArray[i].length] = 0;
+ result = COAP_204_CHANGED;
+ }
+ else
+ {
+ result = COAP_400_BAD_REQUEST;
+ }
+ break;
+
+ default:
+ result = COAP_405_METHOD_NOT_ALLOWED;
+ }
+
+ i++;
+ } while (i < numData && result == COAP_204_CHANGED);
+
+ return result;
+}
+
+static uint8_t prv_device_execute(uint16_t instanceId,
+ uint16_t resourceId,
+ char * buffer,
+ int length,
+ lwm2m_object_t * objectP)
+{
+ // this is a single instance object
+ if (instanceId != 0)
+ {
+ return COAP_404_NOT_FOUND;
+ }
+
+ if (length != 0) return COAP_400_BAD_REQUEST;
+
+ switch (resourceId)
+ {
+ case 4:
+ fprintf(stdout, "\n\t REBOOT\r\n\n");
+ return COAP_204_CHANGED;
+ case 5:
+ fprintf(stdout, "\n\t FACTORY RESET\r\n\n");
+ return COAP_204_CHANGED;
+ case 12:
+ fprintf(stdout, "\n\t RESET ERROR CODE\r\n\n");
+ return COAP_204_CHANGED;
+ default:
+ return COAP_405_METHOD_NOT_ALLOWED;
+ }
+}
+
+lwm2m_object_t * get_object_device()
+{
+ /*
+ * The get_object_device function create the object itself and return a pointer to the structure that represent it.
+ */
+ lwm2m_object_t * deviceObj;
+
+ deviceObj = (lwm2m_object_t *)malloc(sizeof(lwm2m_object_t));
+
+ if (NULL != deviceObj)
+ {
+ memset(deviceObj, 0, sizeof(lwm2m_object_t));
+
+ /*
+ * It assign his unique ID
+ * The 3 is the standard ID for the mandatory object "Object device".
+ */
+ deviceObj->objID = 3;
+
+ /*
+ * And the private function that will access the object.
+ * Those function will be called when a read/write/execute query is made by the server. In fact the library don't need to
+ * know the resources of the object, only the server does.
+ */
+ deviceObj->readFunc = prv_device_read;
+ deviceObj->writeFunc = prv_device_write;
+ deviceObj->executeFunc = prv_device_execute;
+ deviceObj->userData = malloc(sizeof(device_data_t));
+
+ /*
+ * Also some user data can be stored in the object with a private structure containing the needed variables
+ */
+ if (NULL != deviceObj->userData)
+ {
+ ((device_data_t*)deviceObj->userData)->time = 1367491215;
+ strcpy(((device_data_t*)deviceObj->userData)->time_offset, "+02:00");
+ }
+ else
+ {
+ free(deviceObj);
+ deviceObj = NULL;
+ }
+ }
+
+ return deviceObj;
+}
diff --git a/tests/client/object_firmware.c b/tests/client/object_firmware.c
new file mode 100644
index 000000000..0faa66abf
--- /dev/null
+++ b/tests/client/object_firmware.c
@@ -0,0 +1,271 @@
+/*******************************************************************************
+ *
+ * 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:
+ * Julien Vermillard - initial implementation
+ * Fabien Fleutot - Please refer to git log
+ * David Navarro, Intel Corporation - Please refer to git log
+ *
+ *******************************************************************************/
+
+/*
+ * This object is single instance only, and provide firmware upgrade functionality.
+ * Object ID is 5.
+ */
+
+/*
+ * resources:
+ * 0 package write
+ * 1 package url write
+ * 2 update exec
+ * 3 state read
+ * 4 update supported objects read/write
+ * 5 update result read
+ */
+
+#include "liblwm2m.h"
+
+
+#include
+#include
+#include
+#include
+
+#define PRV_TLV_BUFFER_SIZE 128
+
+typedef struct
+{
+ uint8_t state;
+ uint8_t supported;
+ uint8_t result;
+} firmware_data_t;
+
+
+static uint8_t prv_firmware_read(uint16_t instanceId,
+ int * numDataP,
+ lwm2m_tlv_t ** dataArrayP,
+ lwm2m_object_t * objectP)
+{
+ int i;
+ uint8_t result;
+ firmware_data_t * data = (firmware_data_t*)(objectP->userData);
+
+ // this is a single instance object
+ if (instanceId != 0)
+ {
+ return COAP_404_NOT_FOUND;
+ }
+
+ // is the server asking for the full object ?
+ if (*numDataP == 0)
+ {
+ uint16_t resList[] = {0, 1, 2, 3, 6, 7, 8, 9, 10, 11, 13, 14, 15};
+ int nbRes = sizeof(resList)/sizeof(uint16_t);
+
+ *dataArrayP = lwm2m_tlv_new(3);
+ if (*dataArrayP == NULL) return COAP_500_INTERNAL_SERVER_ERROR;
+ *numDataP = 3;
+ (*dataArrayP)[0].id = 3;
+ (*dataArrayP)[1].id = 4;
+ (*dataArrayP)[2].id = 5;
+ }
+
+ i = 0;
+ do
+ {
+ switch ((*dataArrayP)[i].id)
+ {
+ case 0:
+ case 1:
+ case 2:
+ result = COAP_405_METHOD_NOT_ALLOWED;
+ break;
+
+ case 3:
+ // firmware update state (int)
+ lwm2m_tlv_encode_int(data->state, *dataArrayP + i);
+ (*dataArrayP)[i].type = LWM2M_TYPE_RESSOURCE;
+
+ if (0 != (*dataArrayP)[i].length) result = COAP_205_CONTENT;
+ else result = COAP_500_INTERNAL_SERVER_ERROR;
+
+ break;
+
+ case 4:
+ lwm2m_tlv_encode_int(data->supported, *dataArrayP + i);
+ (*dataArrayP)[i].type = LWM2M_TYPE_RESSOURCE;
+
+ if (0 != (*dataArrayP)[i].length) result = COAP_205_CONTENT;
+ else result = COAP_500_INTERNAL_SERVER_ERROR;
+
+ break;
+
+ case 5:
+ lwm2m_tlv_encode_int(data->result, *dataArrayP + i);
+ (*dataArrayP)[i].type = LWM2M_TYPE_RESSOURCE;
+
+ if (0 != (*dataArrayP)[i].length) result = COAP_205_CONTENT;
+ else result = COAP_500_INTERNAL_SERVER_ERROR;
+
+ break;
+
+ default:
+ result = COAP_404_NOT_FOUND;
+ }
+
+ i++;
+ } while (i < *numDataP && result == COAP_205_CONTENT);
+
+ return result;
+}
+
+static uint8_t prv_firmware_write(uint16_t instanceId,
+ int numData,
+ lwm2m_tlv_t * dataArray,
+ lwm2m_object_t * objectP)
+{
+ int i;
+ uint8_t result;
+ firmware_data_t * data = (firmware_data_t*)(objectP->userData);
+
+ // this is a single instance object
+ if (instanceId != 0)
+ {
+ return COAP_404_NOT_FOUND;
+ }
+
+ i = 0;
+
+ do
+ {
+ switch (dataArray[i].id)
+ {
+ case 0:
+ // inline firmware binary
+ result = COAP_204_CHANGED;
+ break;
+
+ case 1:
+ // URL for download the firmware
+ result = COAP_204_CHANGED;
+ break;
+
+ case 4:
+ if (1 == dataArray[i].length && dataArray[i].value[0] == '0')
+ {
+ data->supported = 0;
+ result = COAP_204_CHANGED;
+ }
+ else if (1 == dataArray[i].length && dataArray[i].value[0] == '1')
+ {
+ data->supported = 1;
+ result = COAP_204_CHANGED;
+
+ }
+ else
+ {
+ result = COAP_400_BAD_REQUEST;
+ }
+ break;
+
+ default:
+ result = COAP_405_METHOD_NOT_ALLOWED;
+ }
+
+ i++;
+ } while (i < numData && result == COAP_204_CHANGED);
+
+ return result;
+}
+
+static uint8_t prv_firmware_execute(uint16_t instanceId,
+ uint16_t resourceId,
+ char * buffer,
+ int length,
+ lwm2m_object_t * objectP)
+{
+ firmware_data_t * data = (firmware_data_t*)(objectP->userData);
+
+ // this is a single instance object
+ if (instanceId != 0)
+ {
+ return COAP_404_NOT_FOUND;
+ }
+
+ if (length != 0) return COAP_400_BAD_REQUEST;
+
+ // for execute callback, resId is always set.
+ switch (resourceId)
+ {
+ case 2:
+ if (data->state == 1)
+ {
+ fprintf(stdout, "\n\t FIRMWARE UPDATE\r\n\n");
+ // trigger your firmware download and update logic
+ data->state = 2;
+ return COAP_204_CHANGED;
+ } else {
+ // firmware update already running
+ return COAP_400_BAD_REQUEST;
+ }
+ default:
+ return COAP_405_METHOD_NOT_ALLOWED;
+ }
+}
+
+lwm2m_object_t * get_object_firmware()
+{
+ /*
+ * The get_object_firmware function create the object itself and return a pointer to the structure that represent it.
+ */
+ lwm2m_object_t * firmwareObj;
+
+ firmwareObj = (lwm2m_object_t *)malloc(sizeof(lwm2m_object_t));
+
+ if (NULL != firmwareObj)
+ {
+ memset(firmwareObj, 0, sizeof(lwm2m_object_t));
+
+ /*
+ * It assign his unique ID
+ * The 5 is the standard ID for the optional object "Object firmware".
+ */
+ firmwareObj->objID = 5;
+
+ /*
+ * And the private function that will access the object.
+ * Those function will be called when a read/write/execute query is made by the server. In fact the library don't need to
+ * know the resources of the object, only the server does.
+ */
+ firmwareObj->readFunc = prv_firmware_read;
+ firmwareObj->writeFunc = prv_firmware_write;
+ firmwareObj->executeFunc = prv_firmware_execute;
+ firmwareObj->userData = malloc(sizeof(firmware_data_t));
+
+ /*
+ * Also some user data can be stored in the object with a private structure containing the needed variables
+ */
+ if (NULL != firmwareObj->userData)
+ {
+ ((firmware_data_t*)firmwareObj->userData)->state = 1;
+ ((firmware_data_t*)firmwareObj->userData)->supported = 0;
+ ((firmware_data_t*)firmwareObj->userData)->result = 0;
+ }
+ else
+ {
+ free(firmwareObj);
+ firmwareObj = NULL;
+ }
+ }
+
+ return firmwareObj;
+}
diff --git a/tests/client/test_object.c b/tests/client/test_object.c
new file mode 100644
index 000000000..19faef675
--- /dev/null
+++ b/tests/client/test_object.c
@@ -0,0 +1,289 @@
+/*******************************************************************************
+ *
+ * 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
+ * Axel Lorente - 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
+
+*/
+
+/*
+ * Implements an object for testing purpose
+ *
+ * Multiple
+ * Object | ID | Instances | Mandatoty |
+ * Test | 1024 | Yes | No |
+ *
+ * Ressources:
+ * Supported Multiple
+ * Name | ID | Operations | Instances | Mandatory | Type | Range | Units | Description |
+ * test | 1 | R/W | No | Yes | Integer | 0-255 | | |
+ * exec | 2 | E | No | Yes | | | | |
+ *
+ */
+
+#include "liblwm2m.h"
+
+#include
+#include
+#include
+#include
+
+
+#define PRV_TLV_BUFFER_SIZE 64
+
+/*
+ * Multiple instance objects can use userdata to store data that will be shared between the different instances.
+ * The lwm2m_object_t object structure - which represent every object of the liblwm2m as seen in the single instance
+ * object - contain a chained list called instanceList with the object specific structure prv_instance_t:
+ */
+typedef struct _prv_instance_
+{
+ /*
+ * The first two are mandatories and represent the pointer to the next instance and the ID of this one. The rest
+ * is the instance scope user data (uint8_t test in this case)
+ */
+ struct _prv_instance_ * next; // matches lwm2m_list_t::next
+ uint16_t shortID; // matches lwm2m_list_t::id
+ uint8_t test;
+} prv_instance_t;
+
+static void prv_output_buffer(uint8_t * buffer,
+ int length)
+{
+ int i;
+ uint8_t array[16];
+
+ i = 0;
+ while (i < length)
+ {
+ int j;
+ fprintf(stderr, " ");
+
+ memcpy(array, buffer+i, 16);
+
+ for (j = 0 ; j < 16 && i+j < length; j++)
+ {
+ fprintf(stderr, "%02X ", array[j]);
+ }
+ while (j < 16)
+ {
+ fprintf(stderr, " ");
+ j++;
+ }
+ fprintf(stderr, " ");
+ for (j = 0 ; j < 16 && i+j < length; j++)
+ {
+ if (isprint(array[j]))
+ fprintf(stderr, "%c ", array[j]);
+ else
+ fprintf(stderr, ". ");
+ }
+ fprintf(stderr, "\n");
+
+ i += 16;
+ }
+}
+
+static uint8_t prv_read(uint16_t instanceId,
+ int * numDataP,
+ lwm2m_tlv_t ** dataArrayP,
+ lwm2m_object_t * objectP)
+{
+ prv_instance_t * targetP;
+ int i;
+
+ targetP = (prv_instance_t *)lwm2m_list_find(objectP->instanceList, instanceId);
+ if (NULL == targetP) return COAP_404_NOT_FOUND;
+
+ if (*numDataP == 0)
+ {
+ *dataArrayP = lwm2m_tlv_new(1);
+ if (*dataArrayP == NULL) return COAP_500_INTERNAL_SERVER_ERROR;
+ *numDataP = 1;
+ (*dataArrayP)->id = 1;
+ }
+
+ if (*numDataP != 1) return COAP_404_NOT_FOUND;
+ if ((*dataArrayP)->id != 1) return COAP_404_NOT_FOUND;
+
+ (*dataArrayP)->type = LWM2M_TYPE_RESSOURCE;
+ lwm2m_tlv_encode_int(targetP->test, *dataArrayP);
+
+ if ((*dataArrayP)->length == 0) return COAP_500_INTERNAL_SERVER_ERROR;
+
+ return COAP_205_CONTENT;
+}
+
+static uint8_t prv_write(uint16_t instanceId,
+ int numData,
+ lwm2m_tlv_t * dataArray,
+ lwm2m_object_t * objectP)
+{
+ prv_instance_t * targetP;
+ int64_t value;
+
+ targetP = (prv_instance_t *)lwm2m_list_find(objectP->instanceList, instanceId);
+ if (NULL == targetP) return COAP_404_NOT_FOUND;
+
+ if (numData != 1 || dataArray->id != 1) return COAP_404_NOT_FOUND;
+
+ if (1 != lwm2m_tlv_decode_int(dataArray, &value)
+ || value < 0 || value > 0xFF)
+ {
+ return COAP_400_BAD_REQUEST;
+ }
+ targetP->test = (uint8_t)value;
+
+ return COAP_204_CHANGED;
+}
+
+static uint8_t prv_delete(uint16_t id,
+ lwm2m_object_t * objectP)
+{
+ prv_instance_t * targetP;
+
+ objectP->instanceList = lwm2m_list_remove(objectP->instanceList, id, (lwm2m_list_t **)&targetP);
+ if (NULL == targetP) return COAP_404_NOT_FOUND;
+
+ free(targetP);
+
+ return COAP_202_DELETED;
+}
+
+static uint8_t prv_create(uint16_t instanceId,
+ int numData,
+ lwm2m_tlv_t * dataArray,
+ lwm2m_object_t * objectP)
+{
+ prv_instance_t * targetP;
+ uint8_t result;
+
+
+ targetP = (prv_instance_t *)malloc(sizeof(prv_instance_t));
+ if (NULL == targetP) return COAP_500_INTERNAL_SERVER_ERROR;
+ memset(targetP, 0, sizeof(prv_instance_t));
+
+ targetP->shortID = instanceId;
+ objectP->instanceList = LWM2M_LIST_ADD(objectP->instanceList, targetP);
+
+ result = prv_write(instanceId, numData, dataArray, objectP);
+
+ if (result != COAP_204_CHANGED)
+ {
+ (void)prv_delete(instanceId, objectP);
+ }
+ else
+ {
+ result = COAP_201_CREATED;
+ }
+
+ return result;
+}
+
+static uint8_t prv_exec(uint16_t instanceId,
+ uint16_t resourceId,
+ char * buffer,
+ int length,
+ lwm2m_object_t * objectP)
+{
+
+ if (NULL == lwm2m_list_find(objectP->instanceList, instanceId)) return COAP_404_NOT_FOUND;
+
+ switch (resourceId)
+ {
+ case 1:
+ return COAP_405_METHOD_NOT_ALLOWED;
+ case 2:
+ fprintf(stdout, "\r\n-----------------\r\n"
+ "Execute on %hu/%d/%d\r\n"
+ " Parameter (%d bytes):\r\n",
+ objectP->objID, instanceId, resourceId, length);
+ prv_output_buffer(buffer, length);
+ fprintf(stdout, "-----------------\r\n\r\n");
+ return COAP_204_CHANGED;
+ default:
+ return COAP_404_NOT_FOUND;
+ }
+}
+
+lwm2m_object_t * get_test_object()
+{
+ lwm2m_object_t * testObj;
+
+ testObj = (lwm2m_object_t *)malloc(sizeof(lwm2m_object_t));
+
+ if (NULL != testObj)
+ {
+ int i;
+ prv_instance_t * targetP;
+
+ memset(testObj, 0, sizeof(lwm2m_object_t));
+
+ testObj->objID = 1024;
+ for (i=0 ; i < 3 ; i++)
+ {
+ targetP = (prv_instance_t *)malloc(sizeof(prv_instance_t));
+ if (NULL == targetP) return NULL;
+ memset(targetP, 0, sizeof(prv_instance_t));
+ targetP->shortID = 10 + i;
+ targetP->test = 20 + i;
+ testObj->instanceList = LWM2M_LIST_ADD(testObj->instanceList, targetP);
+ }
+ /*
+ * From a single instance object, two more functions are available.
+ * - The first one (createFunc) create a new instance and filled it with the provided informations. If an ID is
+ * provided a check is done for verifying his disponibility, or a new one is generated.
+ * - The other one (deleteFunc) delete an instance by removing it from the instance list (and freeing the memory
+ * allocated to it)
+ */
+ testObj->readFunc = prv_read;
+ testObj->writeFunc = prv_write;
+ testObj->createFunc = prv_create;
+ testObj->deleteFunc = prv_delete;
+ testObj->executeFunc = prv_exec;
+ }
+
+ return testObj;
+}
diff --git a/tests/server/CMakeLists.txt b/tests/server/CMakeLists.txt
new file mode 100644
index 000000000..32957e030
--- /dev/null
+++ b/tests/server/CMakeLists.txt
@@ -0,0 +1,15 @@
+cmake_minimum_required (VERSION 2.8.3)
+
+project (lwm2mserver)
+
+SET(LIBLWM2M_DIR ${PROJECT_SOURCE_DIR}/../../core)
+
+add_definitions(-DLWM2M_SERVER_MODE)
+
+include_directories (${LIBLWM2M_DIR} ${PROJECT_SOURCE_DIR}/../utils)
+
+add_subdirectory(${LIBLWM2M_DIR} ${CMAKE_CURRENT_BINARY_DIR}/core)
+
+SET(SOURCES lwm2mserver.c ../utils/commandline.c ../utils/connection.c)
+
+add_executable(lwm2mserver ${SOURCES} ${CORE_SOURCES})
diff --git a/tests/server/lwm2mserver.c b/tests/server/lwm2mserver.c
new file mode 100644
index 000000000..16122f16c
--- /dev/null
+++ b/tests/server/lwm2mserver.c
@@ -0,0 +1,792 @@
+/*******************************************************************************
+ *
+ * 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
+ * Simon Bernard - Please refer to git log
+ * Toby Jaffey - Please refer to git log
+ * Julien Vermillard - 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
+
+*/
+
+
+#include "liblwm2m.h"
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "commandline.h"
+#include "connection.h"
+
+#define MAX_PACKET_SIZE 128
+
+static int g_quit = 0;
+
+static uint8_t prv_buffer_send(void * sessionH,
+ uint8_t * buffer,
+ size_t length,
+ void * userdata)
+{
+ connection_t * connP = (connection_t*) sessionH;
+
+ if (-1 == connection_send(connP, buffer, length))
+ {
+ return COAP_500_INTERNAL_SERVER_ERROR;
+ }
+ return COAP_NO_ERROR;
+}
+
+static void prv_dump_client(lwm2m_client_t * targetP)
+{
+ lwm2m_client_object_t * objectP;
+
+ fprintf(stdout, "Client #%d:\r\n", targetP->internalID);
+ fprintf(stdout, "\tname: \"%s\"\r\n", targetP->name);
+ fprintf(stdout, "\tobjects: ");
+ for (objectP = targetP->objectList; objectP != NULL ; objectP = objectP->next)
+ {
+ if (objectP->instanceList == NULL)
+ {
+ fprintf(stdout, "%d, ", objectP->id);
+ }
+ else
+ {
+ lwm2m_list_t * instanceP;
+
+ for (instanceP = objectP->instanceList; instanceP != NULL ; instanceP = instanceP->next)
+ {
+ fprintf(stdout, "%d/%d, ", objectP->id, instanceP->id);
+ }
+ }
+ }
+ fprintf(stdout, "\r\n");
+}
+
+static void prv_output_clients(char * buffer,
+ void * user_data)
+{
+ lwm2m_context_t * lwm2mH = (lwm2m_context_t *) user_data;
+ lwm2m_client_t * targetP;
+
+ targetP = lwm2mH->clientList;
+
+ if (targetP == NULL)
+ {
+ fprintf(stdout, "No client.\r\n");
+ return;
+ }
+
+ for (targetP = lwm2mH->clientList ; targetP != NULL ; targetP = targetP->next)
+ {
+ prv_dump_client(targetP);
+ }
+}
+
+static void print_indent(int num)
+{
+ int i;
+
+ for ( i = 0 ; i< num ; i++)
+ fprintf(stdout, " ");
+}
+
+static void output_tlv(char * buffer,
+ size_t buffer_len,
+ int indent)
+{
+ lwm2m_tlv_type_t type;
+ uint16_t id;
+ size_t dataIndex;
+ size_t dataLen;
+ int length = 0;
+ int result;
+
+ while (0 != (result = lwm2m_decodeTLV(buffer + length, buffer_len - length, &type, &id, &dataIndex, &dataLen)))
+ {
+ print_indent(indent);
+ fprintf(stdout, "ID: %d", id);
+ fprintf(stdout, " type: ");
+ switch (type)
+ {
+ case TLV_OBJECT_INSTANCE:
+ fprintf(stdout, "Object Instance");
+ break;
+ case TLV_RESSOURCE_INSTANCE:
+ fprintf(stdout, "Ressource Instance");
+ break;
+ case TLV_MULTIPLE_INSTANCE:
+ fprintf(stdout, "Multiple Instances");
+ break;
+ case TLV_RESSOURCE:
+ fprintf(stdout, "Ressource");
+ break;
+ default:
+ printf("unknown (%d)", (int)type);
+ break;
+ }
+ fprintf(stdout, "\n");
+ print_indent(indent);
+ fprintf(stdout, "{\n");
+ if (type == TLV_OBJECT_INSTANCE || type == TLV_MULTIPLE_INSTANCE)
+ {
+ output_tlv(buffer + length + dataIndex, dataLen, indent+2);
+ }
+ else
+ {
+ print_indent(indent+2);
+ fprintf(stdout, "data (%d bytes): ", dataLen);
+ if (dataLen >= 16) fprintf(stdout, "\n");
+ output_buffer(stdout, buffer + length + dataIndex, dataLen);
+ }
+ print_indent(indent);
+ fprintf(stdout, "}\n");
+ length += result;
+ }
+}
+
+static int prv_read_id(char * buffer,
+ uint16_t * idP)
+{
+ int nb;
+ int value;
+
+ nb = sscanf(buffer, "%d", &value);
+ if (nb == 1)
+ {
+ if (value < 0 || value > LWM2M_MAX_ID)
+ {
+ nb = 0;
+ }
+ else
+ {
+ *idP = value;
+ }
+ }
+
+ return nb;
+}
+
+static void prv_result_callback(uint16_t clientID,
+ lwm2m_uri_t * uriP,
+ int status,
+ uint8_t * data,
+ int dataLength,
+ void * userData)
+{
+ fprintf(stdout, "\r\nClient #%d %d", clientID, uriP->objectId);
+ if (LWM2M_URI_IS_SET_INSTANCE(uriP))
+ fprintf(stdout, "/%d", uriP->instanceId);
+ else if (LWM2M_URI_IS_SET_RESOURCE(uriP))
+ fprintf(stdout, "/");
+ if (LWM2M_URI_IS_SET_RESOURCE(uriP))
+ fprintf(stdout, "/%d", uriP->resourceId);
+ fprintf(stdout, " returned status %d.%2d\r\n", (status&0xE0)>>5, status&0x1F);
+
+ if (data != NULL)
+ {
+ fprintf(stdout, "%d bytes received:\r\n", dataLength);
+ if (LWM2M_URI_IS_SET_RESOURCE(uriP))
+ {
+ output_buffer(stdout, data, dataLength);
+ }
+ else
+ {
+ output_tlv(data, dataLength, 2);
+ }
+ }
+
+ fprintf(stdout, "\r\n> ");
+ fflush(stdout);
+}
+
+static void prv_notify_callback(uint16_t clientID,
+ lwm2m_uri_t * uriP,
+ int count,
+ uint8_t * data,
+ int dataLength,
+ void * userData)
+{
+ fprintf(stdout, "\r\nNotify from client #%d %d", clientID, uriP->objectId);
+ if (LWM2M_URI_IS_SET_INSTANCE(uriP))
+ fprintf(stdout, "/%d", uriP->instanceId);
+ else if (LWM2M_URI_IS_SET_RESOURCE(uriP))
+ fprintf(stdout, "/");
+ if (LWM2M_URI_IS_SET_RESOURCE(uriP))
+ fprintf(stdout, "/%d", uriP->resourceId);
+ fprintf(stdout, " number %d\r\n", count);
+
+ if (data != NULL)
+ {
+ fprintf(stdout, "%d bytes received:\r\n", dataLength);
+ output_buffer(stdout, data, dataLength);
+ }
+
+ fprintf(stdout, "\r\n> ");
+ fflush(stdout);
+}
+
+static void prv_read_client(char * buffer,
+ void * user_data)
+{
+ lwm2m_context_t * lwm2mH = (lwm2m_context_t *) user_data;
+ uint16_t clientId;
+ lwm2m_uri_t uri;
+ int result;
+
+ result = prv_read_id(buffer, &clientId);
+ if (result != 1) goto syntax_error;
+
+ buffer = get_next_arg(buffer);
+ if (buffer[0] == 0) goto syntax_error;
+
+ result = lwm2m_stringToUri(buffer, strlen(buffer), &uri);
+ if (result == 0) goto syntax_error;
+
+ result = lwm2m_dm_read(lwm2mH, clientId, &uri, prv_result_callback, NULL);
+
+ if (result == 0)
+ {
+ fprintf(stdout, "OK");
+ }
+ else
+ {
+ fprintf(stdout, "Error %d.%2d", (result&0xE0)>>5, result&0x1F);
+ }
+ return;
+
+syntax_error:
+ fprintf(stdout, "Syntax error !");
+}
+
+static void prv_write_client(char * buffer,
+ void * user_data)
+{
+ lwm2m_context_t * lwm2mH = (lwm2m_context_t *) user_data;
+ uint16_t clientId;
+ lwm2m_uri_t uri;
+ char * uriString;
+ int i;
+ int result;
+
+ result = prv_read_id(buffer, &clientId);
+ if (result != 1) goto syntax_error;
+
+ buffer = get_next_arg(buffer);
+ if (buffer[0] == 0) goto syntax_error;
+ uriString = buffer;
+
+ buffer = get_next_arg(buffer);
+ if (buffer[0] == 0) goto syntax_error;
+
+ i = 0;
+ while (uriString + i < buffer && !isspace(uriString[i]))
+ {
+ i++;
+ }
+ result = lwm2m_stringToUri(uriString, i, &uri);
+ if (result == 0) goto syntax_error;
+
+ result = lwm2m_dm_write(lwm2mH, clientId, &uri, buffer, strlen(buffer), prv_result_callback, NULL);
+
+ if (result == 0)
+ {
+ fprintf(stdout, "OK");
+ }
+ else
+ {
+ fprintf(stdout, "Error %d.%2d", (result&0xE0)>>5, result&0x1F);
+ }
+ return;
+
+syntax_error:
+ fprintf(stdout, "Syntax error !");
+}
+
+static void prv_exec_client(char * buffer,
+ void * user_data)
+{
+ lwm2m_context_t * lwm2mH = (lwm2m_context_t *) user_data;
+ uint16_t clientId;
+ lwm2m_uri_t uri;
+ char * uriString;
+ int i;
+ int result;
+
+ result = prv_read_id(buffer, &clientId);
+ if (result != 1) goto syntax_error;
+
+ buffer = get_next_arg(buffer);
+ if (buffer[0] == 0) goto syntax_error;
+ uriString = buffer;
+
+ buffer = get_next_arg(buffer);
+
+ i = 0;
+ while (uriString + i < buffer && !isspace(uriString[i]))
+ {
+ i++;
+ }
+ result = lwm2m_stringToUri(uriString, i, &uri);
+ if (result == 0) goto syntax_error;
+
+ if (buffer[0] == 0)
+ {
+ result = lwm2m_dm_execute(lwm2mH, clientId, &uri, NULL, 0, prv_result_callback, NULL);
+ }
+ else
+ {
+ result = lwm2m_dm_execute(lwm2mH, clientId, &uri, buffer, strlen(buffer), prv_result_callback, NULL);
+ }
+
+ if (result == 0)
+ {
+ fprintf(stdout, "OK");
+ }
+ else
+ {
+ fprintf(stdout, "Error %d.%2d", (result&0xE0)>>5, result&0x1F);
+ }
+ return;
+
+syntax_error:
+ fprintf(stdout, "Syntax error !");
+}
+
+static void prv_create_client(char * buffer,
+ void * user_data)
+{
+ lwm2m_context_t * lwm2mH = (lwm2m_context_t *) user_data;
+ uint16_t clientId;
+ lwm2m_uri_t uri;
+ char * uriString;
+ int i;
+ int result;
+ uint64_t value;
+ char temp_buffer[MAX_PACKET_SIZE];
+ int temp_length = 0;
+
+
+ //Get Client ID
+ result = prv_read_id(buffer, &clientId);
+ if (result != 1) goto syntax_error;
+
+ buffer = get_next_arg(buffer);
+ if (buffer[0] == 0) goto syntax_error;
+
+ //save Uri start address
+ uriString = buffer;
+
+ //Get Data to Post
+ buffer = get_next_arg(buffer);
+ if (buffer[0] == 0) goto syntax_error;
+
+ //Get Uri
+ i = 0;
+ while (uriString + i < buffer && !isspace(uriString[i]))
+ {
+ i++;
+ }
+ result = lwm2m_stringToUri(uriString, i, &uri);
+ if (result == 0) goto syntax_error;
+
+ // TLV
+
+ /* Client dependent part */
+
+ if (uri.objectId == 1024)
+ {
+ result = lwm2m_PlainTextToInt64(buffer, strlen(buffer), &value);
+ temp_length = lwm2m_intToTLV(TLV_RESSOURCE, value, (uint16_t) 1, temp_buffer, MAX_PACKET_SIZE);
+ }
+ /* End Client dependent part*/
+
+ //Create
+ result = lwm2m_dm_create(lwm2mH, clientId,&uri, temp_buffer, temp_length, prv_result_callback, NULL);
+
+ if (result == 0)
+ {
+ fprintf(stdout, "OK");
+ }
+ else
+ {
+ fprintf(stdout, "Error %d.%2d", (result&0xE0)>>5, result&0x1F);
+ }
+ return;
+
+syntax_error:
+ fprintf(stdout, "Syntax error !");
+}
+
+static void prv_delete_client(char * buffer,
+ void * user_data)
+{
+ lwm2m_context_t * lwm2mH = (lwm2m_context_t *) user_data;
+ uint16_t clientId;
+ lwm2m_uri_t uri;
+ int result;
+
+ result = prv_read_id(buffer, &clientId);
+ if (result != 1) goto syntax_error;
+
+ buffer = get_next_arg(buffer);
+ if (buffer[0] == 0) goto syntax_error;
+
+ result = lwm2m_stringToUri(buffer, strlen(buffer), &uri);
+ if (result == 0) goto syntax_error;
+
+ result = lwm2m_dm_delete(lwm2mH, clientId, &uri, prv_result_callback, NULL);
+
+ if (result == 0)
+ {
+ fprintf(stdout, "OK");
+ }
+ else
+ {
+ fprintf(stdout, "Error %d.%2d", (result&0xE0)>>5, result&0x1F);
+ }
+ return;
+
+syntax_error:
+ fprintf(stdout, "Syntax error !");
+}
+
+static void prv_observe_client(char * buffer,
+ void * user_data)
+{
+ lwm2m_context_t * lwm2mH = (lwm2m_context_t *) user_data;
+ uint16_t clientId;
+ lwm2m_uri_t uri;
+ int result;
+
+ result = prv_read_id(buffer, &clientId);
+ if (result != 1) goto syntax_error;
+
+ buffer = get_next_arg(buffer);
+ if (buffer[0] == 0) goto syntax_error;
+
+ result = lwm2m_stringToUri(buffer, strlen(buffer), &uri);
+ if (result == 0) goto syntax_error;
+
+ result = lwm2m_observe(lwm2mH, clientId, &uri, prv_notify_callback, NULL);
+
+ if (result == 0)
+ {
+ fprintf(stdout, "OK");
+ }
+ else
+ {
+ fprintf(stdout, "Error %d.%2d", (result&0xE0)>>5, result&0x1F);
+ }
+ return;
+
+syntax_error:
+ fprintf(stdout, "Syntax error !");
+}
+
+static void prv_cancel_client(char * buffer,
+ void * user_data)
+{
+ lwm2m_context_t * lwm2mH = (lwm2m_context_t *) user_data;
+ uint16_t clientId;
+ lwm2m_uri_t uri;
+ int result;
+
+ result = prv_read_id(buffer, &clientId);
+ if (result != 1) goto syntax_error;
+
+ buffer = get_next_arg(buffer);
+ if (buffer[0] == 0) goto syntax_error;
+
+ result = lwm2m_stringToUri(buffer, strlen(buffer), &uri);
+ if (result == 0) goto syntax_error;
+
+ result = lwm2m_observe_cancel(lwm2mH, clientId, &uri, prv_result_callback, NULL);
+
+ if (result == 0)
+ {
+ fprintf(stdout, "OK");
+ }
+ else
+ {
+ fprintf(stdout, "Error %d.%2d", (result&0xE0)>>5, result&0x1F);
+ }
+ return;
+
+syntax_error:
+ fprintf(stdout, "Syntax error !");
+}
+
+static void prv_monitor_callback(uint16_t clientID,
+ lwm2m_uri_t * uriP,
+ int status,
+ uint8_t * data,
+ int dataLength,
+ void * userData)
+{
+ lwm2m_context_t * lwm2mH = (lwm2m_context_t *) userData;
+ lwm2m_client_t * targetP;
+ lwm2m_client_object_t * objectP;
+
+ switch (status)
+ {
+ case COAP_201_CREATED:
+ fprintf(stdout, "\r\nNew client #%d registered.\r\n", clientID);
+
+ targetP = (lwm2m_client_t *)lwm2m_list_find((lwm2m_list_t *)lwm2mH->clientList, clientID);
+
+ prv_dump_client(targetP);
+ break;
+
+ case COAP_202_DELETED:
+ fprintf(stdout, "\r\nClient #%d unregistered.\r\n", clientID);
+ break;
+
+ default:
+ fprintf(stdout, "\r\nMonitor callback called with an unknown status: %d.\r\n", status);
+ break;
+ }
+
+ fprintf(stdout, "\r\n> ");
+ fflush(stdout);
+}
+
+
+static void prv_quit(char * buffer,
+ void * user_data)
+{
+ g_quit = 1;
+}
+
+void handle_sigint(int signum)
+{
+ prv_quit(NULL, NULL);
+}
+
+void print_usage(void)
+{
+ fprintf(stderr, "Usage: lwm2mserver\r\n");
+ fprintf(stderr, "Launch a LWM2M server on localhost port "LWM2M_STANDARD_PORT_STR".\r\n\n");
+}
+
+
+int main(int argc, char *argv[])
+{
+ int sock;
+ fd_set readfds;
+ struct timeval tv;
+ int result;
+ lwm2m_context_t * lwm2mH = NULL;
+ int i;
+ connection_t * connList = NULL;
+
+ command_desc_t commands[] =
+ {
+ {"list", "List registered clients.", NULL, prv_output_clients, NULL},
+ {"read", "Read from a client.", " read CLIENT# URI\r\n"
+ " CLIENT#: client number as returned by command 'list'\r\n"
+ " URI: uri to read such as /3, /3//2, /3/0/2, /1024/11, /1024//1\r\n"
+ "Result will be displayed asynchronously.", prv_read_client, NULL},
+ {"write", "Write to a client.", " write CLIENT# URI DATA\r\n"
+ " CLIENT#: client number as returned by command 'list'\r\n"
+ " URI: uri to write to such as /3, /3//2, /3/0/2, /1024/11, /1024//1\r\n"
+ " DATA: data to write\r\n"
+ "Result will be displayed asynchronously.", prv_write_client, NULL},
+ {"exec", "Execute a client resource.", " exec CLIENT# URI\r\n"
+ " CLIENT#: client number as returned by command 'list'\r\n"
+ " URI: uri of the resource to execute such as /3/0/2\r\n"
+ "Result will be displayed asynchronously.", prv_exec_client, NULL},
+ {"del", "Delete a client Object instance.", " del CLIENT# URI\r\n"
+ " CLIENT#: client number as returned by command 'list'\r\n"
+ " URI: uri of the instance to delete such as /1024/11\r\n"
+ "Result will be displayed asynchronously.", prv_delete_client, NULL},
+ {"create", "create an Object instance.", " create CLIENT# URI DATA\r\n"
+ " CLIENT#: client number as returned by command 'list'\r\n"
+ " URI: uri to which create the Object Instance such as /1024, /1024/45 \r\n"
+ " DATA: data to initialize the new Object Instance (0-255 for object 1024) \r\n"
+ "Result will be displayed asynchronously.", prv_create_client, NULL},
+ {"observe", "Observe from a client.", " observe CLIENT# URI\r\n"
+ " CLIENT#: client number as returned by command 'list'\r\n"
+ " URI: uri to observe such as /3, /3/0/2, /1024/11\r\n"
+ "Result will be displayed asynchronously.", prv_observe_client, NULL},
+ {"cancel", "Cancel an observe.", " cancel CLIENT# URI\r\n"
+ " CLIENT#: client number as returned by command 'list'\r\n"
+ " URI: uri on which to cancel an observe such as /3, /3/0/2, /1024/11\r\n"
+ "Result will be displayed asynchronously.", prv_cancel_client, NULL},
+
+ {"quit", "Quit the server.", NULL, prv_quit, NULL},
+
+ COMMAND_END_LIST
+ };
+
+ sock = create_socket(LWM2M_STANDARD_PORT_STR);
+ if (sock < 0)
+ {
+ fprintf(stderr, "Error opening socket: %d\r\n", errno);
+ return -1;
+ }
+
+ lwm2mH = lwm2m_init("testlwm2mserver", 0, NULL, prv_buffer_send, NULL);
+ if (NULL == lwm2mH)
+ {
+ fprintf(stderr, "lwm2m_init() failed\r\n");
+ return -1;
+ }
+
+ signal(SIGINT, handle_sigint);
+
+ for (i = 0 ; commands[i].name != NULL ; i++)
+ {
+ commands[i].userData = (void *)lwm2mH;
+ }
+ fprintf(stdout, "> "); fflush(stdout);
+
+ lwm2m_set_monitoring_callback(lwm2mH, prv_monitor_callback, lwm2mH);
+
+ while (0 == g_quit)
+ {
+ FD_ZERO(&readfds);
+ FD_SET(sock, &readfds);
+ FD_SET(STDIN_FILENO, &readfds);
+
+ tv.tv_sec = 60;
+ tv.tv_usec = 0;
+
+ result = lwm2m_step(lwm2mH, &tv);
+ if (result != 0)
+ {
+ fprintf(stderr, "lwm2m_step() failed: 0x%X\r\n", result);
+ return -1;
+ }
+
+ result = select(FD_SETSIZE, &readfds, 0, 0, &tv);
+
+ if ( result < 0 )
+ {
+ if (errno != EINTR)
+ {
+ fprintf(stderr, "Error in select(): %d\r\n", errno);
+ }
+ }
+ else if (result > 0)
+ {
+ uint8_t buffer[MAX_PACKET_SIZE];
+ int numBytes;
+
+ if (FD_ISSET(sock, &readfds))
+ {
+ struct sockaddr_storage addr;
+ socklen_t addrLen;
+
+ addrLen = sizeof(addr);
+ numBytes = recvfrom(sock, buffer, MAX_PACKET_SIZE, 0, (struct sockaddr *)&addr, &addrLen);
+
+ if (numBytes == -1)
+ {
+ fprintf(stderr, "Error in recvfrom(): %d\r\n", errno);
+ }
+ else
+ {
+ char s[INET6_ADDRSTRLEN];
+ connection_t * connP;
+
+ fprintf(stderr, "%d bytes received from [%s]:%hu\r\n",
+ numBytes,
+ inet_ntop(addr.ss_family,
+ &(((struct sockaddr_in6*)&addr)->sin6_addr),
+ s,
+ INET6_ADDRSTRLEN),
+ ntohs(((struct sockaddr_in6*)&addr)->sin6_port));
+ output_buffer(stderr, buffer, numBytes);
+
+ connP = connection_find(connList, &addr, addrLen);
+ if (connP == NULL)
+ {
+ connList = connection_new_incoming(connList, sock, (struct sockaddr *)&addr, addrLen);
+ connP = connList;
+ }
+ if (connP != NULL)
+ {
+ lwm2m_handle_packet(lwm2mH, buffer, numBytes, connP);
+ }
+ }
+ }
+ else if (FD_ISSET(STDIN_FILENO, &readfds))
+ {
+ numBytes = read(STDIN_FILENO, buffer, MAX_PACKET_SIZE);
+
+ if (numBytes > 1)
+ {
+ buffer[numBytes - 1] = 0;
+ handle_command(commands, buffer);
+ }
+ if (g_quit == 0)
+ {
+ fprintf(stdout, "\r\n> ");
+ fflush(stdout);
+ }
+ else
+ {
+ fprintf(stdout, "\r\n");
+ }
+ }
+ }
+ }
+
+ lwm2m_close(lwm2mH);
+ close(sock);
+ connection_free(connList);
+
+ return 0;
+}
diff --git a/tests/utils/commandline.c b/tests/utils/commandline.c
new file mode 100644
index 000000000..35f5b06b4
--- /dev/null
+++ b/tests/utils/commandline.c
@@ -0,0 +1,127 @@
+/*******************************************************************************
+ *
+ * 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
+ * Fabien Fleutot - Please refer to git log
+ *
+ *******************************************************************************/
+
+#include
+#include
+#include
+#include
+
+#include "commandline.h"
+
+#define HELP_COMMAND "help"
+#define HELP_DESC "Type '"HELP_COMMAND" [COMMAND]' for more details on a command."
+#define UNKNOWN_CMD_MSG "Unknown command. Type '"HELP_COMMAND"' for help."
+
+
+static command_desc_t * prv_find_command(command_desc_t * commandArray,
+ char * buffer,
+ int length)
+{
+ int i;
+
+ if (length == 0) return NULL;
+
+ i = 0;
+ while (commandArray[i].name != NULL
+ && (strlen(commandArray[i].name) != length || strncmp(buffer, commandArray[i].name, length)))
+ {
+ i++;
+ }
+
+ if (commandArray[i].name == NULL)
+ {
+ return NULL;
+ }
+ else
+ {
+ return &commandArray[i];
+ }
+}
+
+static void prv_displayHelp(command_desc_t * commandArray,
+ char * buffer)
+{
+ command_desc_t * cmdP;
+ int length;
+
+ // find end of first argument
+ length = 0;
+ while (buffer[length] != 0 && !isspace(buffer[length]))
+ length++;
+
+ cmdP = prv_find_command(commandArray, buffer, length);
+
+ if (cmdP == NULL)
+ {
+ int i;
+
+ fprintf(stdout, HELP_COMMAND"\t"HELP_DESC"\r\n");
+
+ for (i = 0 ; commandArray[i].name != NULL ; i++)
+ {
+ fprintf(stdout, "%s\t%s\r\n", commandArray[i].name, commandArray[i].shortDesc);
+ }
+ }
+ else
+ {
+ fprintf(stdout, "%s\r\n", cmdP->longDesc?cmdP->longDesc:cmdP->shortDesc);
+ }
+}
+
+
+void handle_command(command_desc_t * commandArray,
+ char * buffer)
+{
+ command_desc_t * cmdP;
+ int length;
+
+ // find end of command name
+ length = 0;
+ while (buffer[length] != 0 && !isspace(buffer[length]))
+ length++;
+
+ cmdP = prv_find_command(commandArray, buffer, length);
+ if (cmdP != NULL)
+ {
+ while (buffer[length] != 0 && isspace(buffer[length]))
+ length++;
+ cmdP->callback(buffer + length, cmdP->userData);
+ }
+ else
+ {
+ if (!strncmp(buffer, HELP_COMMAND, length))
+ {
+ while (buffer[length] != 0 && isspace(buffer[length]))
+ length++;
+ prv_displayHelp(commandArray, buffer + length);
+ }
+ else
+ {
+ fprintf(stdout, UNKNOWN_CMD_MSG"\r\n");
+ }
+ }
+}
+
+char * get_next_arg(char * buffer)
+{
+ while (buffer[0] != 0 && !isspace(buffer[0])) buffer++;
+ while (buffer[0] != 0 && isspace(buffer[0])) buffer++;
+
+ return buffer;
+}
+
diff --git a/tests/utils/commandline.h b/tests/utils/commandline.h
new file mode 100644
index 000000000..439cacc8a
--- /dev/null
+++ b/tests/utils/commandline.h
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ *
+ * Copyright (c) 2013 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
+ *
+ *******************************************************************************/
+
+#define COMMAND_END_LIST {NULL, NULL, NULL, NULL, NULL}
+
+typedef void (*command_handler_t) (char * args, void * user_data);
+
+typedef struct
+{
+ char * name;
+ char * shortDesc;
+ char * longDesc;
+ command_handler_t callback;
+ void * userData;
+} command_desc_t;
+
+
+void handle_command(command_desc_t * commandArray, char * buffer);
+char * get_next_arg(char * buffer);
diff --git a/tests/utils/connection.c b/tests/utils/connection.c
new file mode 100644
index 000000000..5e51c5be9
--- /dev/null
+++ b/tests/utils/connection.c
@@ -0,0 +1,219 @@
+/*******************************************************************************
+ *
+ * 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
+ *
+ *******************************************************************************/
+
+#include
+#include
+#include "connection.h"
+
+
+int create_socket(char * portStr)
+{
+ int s = -1;
+ struct addrinfo hints;
+ struct addrinfo *res;
+ struct addrinfo *p;
+
+ memset(&hints, 0, sizeof hints);
+ hints.ai_family = AF_INET;
+ hints.ai_socktype = SOCK_DGRAM;
+ hints.ai_flags = AI_PASSIVE;
+
+ if (0 != getaddrinfo(NULL, portStr, &hints, &res))
+ {
+ return -1;
+ }
+
+ for(p = res ; p != NULL && s == -1 ; p = p->ai_next)
+ {
+ s = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
+ if (s >= 0)
+ {
+ if (-1 == bind(s, p->ai_addr, p->ai_addrlen))
+ {
+ close(s);
+ s = -1;
+ }
+ }
+ }
+
+ freeaddrinfo(res);
+
+ return s;
+}
+
+connection_t * connection_find(connection_t * connList,
+ struct sockaddr_storage * addr,
+ size_t addrLen)
+{
+ connection_t * connP;
+
+ connP = connList;
+ while (connP != NULL)
+ {
+ if ((connP->addrLen == addrLen)
+ && (memcmp(&(connP->addr), addr, addrLen) == 0))
+ {
+ return connP;
+ }
+ connP = connP->next;
+ }
+
+ return connP;
+}
+
+connection_t * connection_new_incoming(connection_t * connList,
+ int sock,
+ struct sockaddr * addr,
+ size_t addrLen)
+{
+ connection_t * connP;
+
+ connP = (connection_t *)malloc(sizeof(connection_t));
+ if (connP != NULL)
+ {
+ connP->sock = sock;
+ memcpy(&(connP->addr), addr, addrLen);
+ connP->addrLen = addrLen;
+ connP->next = connList;
+ }
+
+ return connP;
+}
+
+connection_t * connection_create(connection_t * connList,
+ int sock,
+ char * host,
+ uint16_t port)
+{
+ char portStr[6];
+ struct addrinfo hints;
+ struct addrinfo *servinfo = NULL;
+ struct addrinfo *p;
+ int s;
+ struct sockaddr *sa;
+ socklen_t sl;
+ connection_t * connP = NULL;
+
+ memset(&hints, 0, sizeof(hints));
+ hints.ai_family = AF_INET;
+ hints.ai_socktype = SOCK_DGRAM;
+
+ if (0 >= sprintf(portStr, "%hu", port)) return NULL;
+ if (0 != getaddrinfo(host, portStr, &hints, &servinfo) || servinfo == NULL) return NULL;
+
+ // we test the various addresses
+ s = -1;
+ for(p = servinfo ; p != NULL && s == -1 ; p = p->ai_next)
+ {
+ s = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
+ if (s >= 0)
+ {
+ sa = p->ai_addr;
+ sl = p->ai_addrlen;
+ if (-1 == connect(s, p->ai_addr, p->ai_addrlen))
+ {
+ close(s);
+ s = -1;
+ }
+ }
+ }
+
+ if (s >= 0)
+ {
+ connP = connection_new_incoming(connList, sock, sa, sl);
+ close(s);
+ }
+
+ return connP;
+}
+
+void connection_free(connection_t * connList)
+{
+ if (connList != NULL)
+ {
+ connection_t * nextP;
+
+ nextP = connList->next;
+ free(connList);
+
+ connection_free(nextP);
+ }
+}
+
+int connection_send(connection_t *connP,
+ uint8_t * buffer,
+ size_t length)
+{
+ size_t nbSent;
+ size_t offset;
+
+ offset = 0;
+ while (offset != length)
+ {
+ nbSent = sendto(connP->sock, buffer + offset, length - offset, 0, (struct sockaddr *)&(connP->addr), connP->addrLen);
+ if (nbSent == -1) return -1;
+ offset += nbSent;
+ }
+ return 0;
+}
+
+void output_buffer(FILE * stream,
+ uint8_t * buffer,
+ int length)
+{
+ int i;
+ int j;
+ uint8_t array[16];
+
+ i = 0;
+ while (i < length)
+ {
+
+ fprintf(stream, " ");
+ memcpy(array, buffer+i, 16);
+
+ for (j = 0 ; j < 16 && i+j < length; j++)
+ {
+ fprintf(stream, "%02X ", array[j]);
+ }
+ if (i != 0)
+ {
+ while (j < 16)
+ {
+ fprintf(stream, " ");
+ j++;
+ }
+ }
+ fprintf(stream, " ");
+ for (j = 0 ; j < 16 && i+j < length; j++)
+ {
+ if (isprint(array[j]))
+ {
+ fprintf(stream, "%c ", array[j]);
+ }
+ else
+ {
+ fprintf(stream, ". ");
+ }
+ }
+ fprintf(stream, "\n");
+
+ i += 16;
+ }
+}
+
+
diff --git a/tests/utils/connection.h b/tests/utils/connection.h
new file mode 100644
index 000000000..c228ec470
--- /dev/null
+++ b/tests/utils/connection.h
@@ -0,0 +1,51 @@
+/*******************************************************************************
+ *
+ * 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
+ *
+ *******************************************************************************/
+
+#ifndef CONNECTION_H_
+#define CONNECTION_H_
+
+#include
+#include
+#include
+#include
+#include
+#include
+
+#define LWM2M_STANDARD_PORT_STR "5684"
+#define LWM2M_STANDARD_PORT 5684
+
+typedef struct _connection_t
+{
+ struct _connection_t * next;
+ int sock;
+ struct sockaddr_in6 addr;
+ size_t addrLen;
+} connection_t;
+
+int create_socket(char * portStr);
+
+connection_t * connection_find(connection_t * connList, struct sockaddr_storage * addr, size_t addrLen);
+connection_t * connection_new_incoming(connection_t * connList, int sock, struct sockaddr * addr, size_t addrLen);
+connection_t * connection_create(connection_t * connList, int sock, char * host, uint16_t port);
+
+void connection_free(connection_t * connList);
+
+int connection_send(connection_t *connP, uint8_t * buffer, size_t length);
+
+void output_buffer(FILE * stream, uint8_t * buffer, int length);
+
+#endif