build_linux_secured $1 $2
build_linux_unsecured_with_ra $1 $2
build_linux_secured_with_ra $1 $2
+ build_linux_unsecured_with_rd $1 $2
+ build_linux_secured_with_rd $1 $2
fi
build_android $1 $2
scons RELEASE=$1 WITH_RA=1 SECURED=1 $2
}
+function build_linux_unsecured_with_rd()
+{
+ echo "*********** Build for linux With Resource Directory *************"
+ scons RELEASE=$1 WITH_RD=1 $2
+}
+
+function build_linux_secured_with_rd()
+{
+ echo "*********** Build for linux With Resource Directory & Security ************"
+ scons RELEASE=$1 WITH_RD=1 SECURED=1 $2
+}
+
function build_android()
{
# Note: for android, as oic-resource uses C++11 feature stoi and to_string,
# it requires gcc-4.9, currently only android-ndk-r10(for linux)
# and windows android-ndk-r10(64bit target version) support these features.
- echo "*********** Build Boost for android ***********"
- # disable parallel build for android as gradle depends on scons to finish first
- export SCONSFLAGS="-Q"
+ build_android_x86 $1 $2
+ build_android_armeabi $1 $2
+ }
+
+ function build_android_x86()
+ {
echo "*********** Build for android x86 *************"
scons TARGET_OS=android TARGET_ARCH=x86 RELEASE=$1 TARGET_TRANSPORT=IP $2
+ scons TARGET_OS=android TARGET_ARCH=x86 RELEASE=$1 TARGET_TRANSPORT=BT $2
+ scons TARGET_OS=android TARGET_ARCH=x86 RELEASE=$1 TARGET_TRANSPORT=BLE $2
+ }
+ function build_android_armeabi()
+ {
echo "*********** Build for android armeabi *************"
scons TARGET_OS=android TARGET_ARCH=armeabi RELEASE=$1 TARGET_TRANSPORT=IP $2
-
- # enable parallel build
- export SCONSFLAGS="-Q -j 4"
+ scons TARGET_OS=android TARGET_ARCH=armeabi RELEASE=$1 TARGET_TRANSPORT=BT $2
+ scons TARGET_OS=android TARGET_ARCH=armeabi RELEASE=$1 TARGET_TRANSPORT=BLE $2
}
function build_arduino()
echo "*********** Build for arduino avr *************"
scons resource TARGET_OS=arduino UPLOAD=false BOARD=mega TARGET_ARCH=avr TARGET_TRANSPORT=IP SHIELD=ETH RELEASE=$1 $2
scons resource TARGET_OS=arduino UPLOAD=false BOARD=mega TARGET_ARCH=avr TARGET_TRANSPORT=IP SHIELD=WIFI RELEASE=$1 $2
+ scons resource TARGET_OS=arduino UPLOAD=false BOARD=mega TARGET_ARCH=avr TARGET_TRANSPORT=BLE SHIELD=RBL_NRF8001 RELEASE=$1 $2
echo "*********** Build for arduino arm *************"
scons resource TARGET_OS=arduino UPLOAD=false BOARD=arduino_due_x TARGET_ARCH=arm TARGET_TRANSPORT=IP SHIELD=ETH RELEASE=$1 $2
scons resource TARGET_OS=arduino UPLOAD=false BOARD=arduino_due_x TARGET_ARCH=arm TARGET_TRANSPORT=IP SHIELD=WIFI RELEASE=$1 $2
+ # BLE support for the Arduino Due is currently unavailable.
}
function build_tizen()
echo "Usage:"
echo " build:"
echo " `basename $0` <target_build>"
- echo " Allowed values for <target_build>: all, linux_unsecured, linux_secured, linux_unsecured_with_ra, linux_secured_with_ra, android, arduino, tizen, darwin"
- echo " Note: \"linux\" will build \"linux_unsecured\", \"linux_secured\", \"linux_unsecured_with_ra\" & \"linux_secured_with_ra\"."
+ echo " Allowed values for <target_build>: all, linux_unsecured, linux_secured, linux_unsecured_with_ra, linux_secured_with_ra, linux_unsecured_with_rd, linux_secured_with_rd, android, arduino, tizen, darwin"
+ echo " Note: \"linux\" will build \"linux_unsecured\", \"linux_secured\", \"linux_unsecured_with_ra\", \"linux_secured_with_ra\", \"linux_secured_with_rd\" & \"linux_unsecured_with_rd\"."
echo " Any selection will build both debug and release versions of all available targets in the scope you've"
echo " selected. To choose any specific command, please use the SCons commandline directly. Please refer"
echo " to [IOTIVITY_REPO]/Readme.scons.txt."
then
build_linux_secured_with_ra true
build_linux_secured_with_ra false
+ elif [ $1 = 'linux_unsecured_with_rd' ]
+ then
+ build_linux_unsecured_with_rd true
+ build_linux_unsecured_with_rd false
+ elif [ $1 = 'linux_secured_with_rd' ]
+ then
+ build_linux_secured_with_rd true
+ build_linux_secured_with_rd false
elif [ $1 = 'android' ]
then
build_android true
build_android false
+ elif [ $1 = 'android_x86' ]
+ then
+ build_android_x86 true
+ build_android_x86 false
+ elif [ $1 = 'android_armeabi' ]
+ then
+ build_android_armeabi true
+ build_android_armeabi false
elif [ $1 = 'arduino' ]
then
build_arduino true
fi
echo "===================== done ====================="
-
-
help_vars.Add(BoolVariable('WITH_RA', 'Build with Remote Access module', False))
+help_vars.Add(EnumVariable('WITH_RD', 'Build including Resource Directory', '0', allowed_values=('0', '1')))
if target_os in targets_disallow_multitransport:
help_vars.Add(ListVariable('TARGET_TRANSPORT', 'Target transport', 'IP', ['BT', 'BLE', 'IP']))
else:
- help_vars.Add(ListVariable('TARGET_TRANSPORT', 'Target transport', 'ALL', ['ALL', 'BT', 'BLE', 'IP']))
+ help_vars.Add(ListVariable('TARGET_TRANSPORT', 'Target transport', 'ALL', ['ALL', 'BT', 'BLE', 'IP', 'TCP']))
help_vars.Add(EnumVariable('TARGET_ARCH', 'Target architecture', default_arch, os_arch_map[target_os]))
help_vars.Add(EnumVariable('SECURED', 'Build with DTLS', '0', allowed_values=('0', '1')))
help_vars.Add(EnumVariable('TEST', 'Run unit tests', '0', allowed_values=('0', '1')))
help_vars.Add(BoolVariable('LOGGING', 'Enable stack logging', logging_default))
help_vars.Add(BoolVariable('UPLOAD', 'Upload binary ? (For Arduino)', require_upload))
+ help_vars.Add(EnumVariable('ROUTING', 'Enable routing', 'EP', allowed_values=('GW', 'EP')))
help_vars.Add(EnumVariable('BUILD_SAMPLE', 'Build with sample', 'ON', allowed_values=('ON', 'OFF')))
help_vars.AddVariables(('DEVICE_NAME', 'Network display name for device (For Arduino)', device_name, None, None),)
help_vars.Add(PathVariable('ANDROID_NDK', 'Android NDK path', None, PathVariable.PathAccept))
if target_os in ['android', 'arduino']: # Android/Arduino always uses GNU compiler regardless of the host
env = Environment(variables = help_vars,
- tools = ['gnulink', 'gcc', 'g++', 'ar', 'as']
+ tools = ['gnulink', 'gcc', 'g++', 'ar', 'as', 'textfile']
)
else:
- env = Environment(variables = help_vars, TARGET_ARCH = target_arch, TARGET_OS = target_os, PREFIX = GetOption('prefix'))
+ env = Environment(variables = help_vars, tools = ['default', 'textfile'], TARGET_ARCH = target_arch, TARGET_OS = target_os, PREFIX = GetOption('prefix'))
Help(help_vars.GenerateHelpText(env))
i_n = ienv.Install(env.get('BUILD_DIR'), targets)
ienv.Alias("install", i_n)
+ def __installheader(ienv, targets, dir, name):
+ user_prefix = env.get('PREFIX')
+ if user_prefix:
+ i_n = ienv.Install(user_prefix + '/include/' + dir ,targets)
+ else:
+ i_n = ienv.Install(env.get('BUILD_DIR'), targets)
+ ienv.Alias("install", i_n)
+
+ def __installpcfile(ienv, targets, name):
+ user_prefix = env.get('PREFIX')
+ if user_prefix:
+ i_n = ienv.Install(user_prefix + '/lib/pkgconfig', targets)
+ else:
+ i_n = ienv.Install(env.get('BUILD_DIR'), targets)
+ ienv.Alias("install", i_n)
+
def __append_target(ienv, name, targets = None):
if targets:
env.Alias(name, targets)
env.AddMethod(__install, 'InstallTarget')
env.AddMethod(__installlib, 'UserInstallTargetLib')
env.AddMethod(__installbin, 'UserInstallTargetBin')
+ env.AddMethod(__installheader, 'UserInstallTargetHeader')
+ env.AddMethod(__installpcfile, 'UserInstallTargetPCFile')
env.SetDir(env.GetLaunchDir())
env['ROOT_DIR']=env.GetLaunchDir()+'/..'
Export('env')
######################################################################
+ # Scons to generate the iotivity.pc file from iotivity.pc.in file
+ ######################################################################
+ pc_file = env.get('SRC_DIR') + '/iotivity.pc.in'
+
+ user_prefix = env.get('PREFIX')
+
+ if user_prefix:
+ pc_vars = {'\@PREFIX\@': user_prefix, '\@EXEC_PREFIX\@':user_prefix, '\@VERSION\@':'0.9.2'}
+ else:
+ pc_vars = {'\@PREFIX\@': env.get('BUILD_DIR'), '\@EXEC_PREFIX\@': env.get('BUILD_DIR'), '\@VERSION\@':'0.9.2'}
+
+ env.Substfile(pc_file, SUBST_DICT = pc_vars)
+
+ ######################################################################
# Link scons to Yocto cross-toolchain ONLY when target_os is yocto
######################################################################
if target_os == "yocto":
liboctbstack_env.AppendUnique(CPPDEFINES = ['WITH_POSIX'])
liboctbstack_env.AppendUnique(CFLAGS = ['-std=c99'])
+ if liboctbstack_env.get('ROUTING') == 'GW':
+ liboctbstack_env.AppendUnique(CPPDEFINES = ['ROUTING_GATEWAY'])
+ elif liboctbstack_env.get('ROUTING') == 'EP':
+ liboctbstack_env.AppendUnique(CPPDEFINES = ['ROUTING_EP'])
+
if target_os not in ['windows', 'winrt']:
liboctbstack_env.AppendUnique(CFLAGS = ['-Wall'])
if env.get('LOGGING'):
liboctbstack_env.AppendUnique(CPPDEFINES = ['TB_LOG'])
+if env.get('WITH_RD') == '1':
+ liboctbstack_env.PrependUnique(CPPPATH = ['../../service/resource-directory/include'])
+ liboctbstack_env.AppendUnique(CPPDEFINES = ['-DWITH_RD'])
+ liboctbstack_env.AppendUnique(LIBS = ['resource_directory'])
+
liboctbstack_env.Append(LIBS = ['c_common'])
+ if liboctbstack_env.get('ROUTING') in ['GW', 'EP']:
+ liboctbstack_env.Prepend(LIBS = ['routingmanager'])
+
######################################################################
# Source files and Targets
######################################################################
static_liboctbstack = liboctbstack_env.StaticLibrary('octbstack', liboctbstack_src)
liboctbstack_env.InstallTarget(static_liboctbstack, 'liboctbstack')
liboctbstack_env.UserInstallTargetLib(static_liboctbstack, 'liboctbstack')
+ liboctbstack_env.UserInstallTargetHeader('stack/include/ocstackconfig.h', 'resource', 'ocstackconfig.h')
+ liboctbstack_env.UserInstallTargetHeader('stack/include/octypes.h', 'resource', 'octypes.h')
else:
static_liboctbstack = liboctbstack_env.StaticLibrary('octbstack', liboctbstack_src)
shared_liboctbstack = liboctbstack_env.SharedLibrary('octbstack', liboctbstack_src)
liboctbstack_env.InstallTarget([static_liboctbstack, shared_liboctbstack], 'liboctbstack')
liboctbstack_env.UserInstallTargetLib([static_liboctbstack, shared_liboctbstack], 'liboctbstack')
+ liboctbstack_env.UserInstallTargetHeader('stack/include/ocstackconfig.h', 'resource', 'ocstackconfig.h')
+ liboctbstack_env.UserInstallTargetHeader('stack/include/octypes.h', 'resource', 'octypes.h')
+ liboctbstack_env.UserInstallTargetHeader('stack/include/ocstack.h', 'resource', 'ocstack.h')
#include <stdbool.h>
#include <inttypes.h>
- #include "logger.h"
#include "octypes.h"
+#ifdef WITH_RD
+#include "rd_payload.h"
+#endif
+
#ifdef __cplusplus
extern "C"
{
bool OCRepPayloadSetPropString(OCRepPayload* payload, const char* name, const char* value);
bool OCRepPayloadSetPropStringAsOwner(OCRepPayload* payload, const char* name, char* value);
- bool OCRepPayloadGetPropString(const OCRepPayload* payload, const char* name, const char** value);
+ bool OCRepPayloadGetPropString(const OCRepPayload* payload, const char* name, char** value);
bool OCRepPayloadSetPropBool(OCRepPayload* payload, const char* name, bool value);
bool OCRepPayloadGetPropBool(const OCRepPayload* payload, const char* name, bool* value);
/** Resource Type.*/
#define OC_RSRVD_RESOURCE_TYPES_URI "/oic/res/types/d"
-
+ #ifdef ROUTING_GATEWAY
+ /** Gateway URI.*/
+ #define OC_RSRVD_GATEWAY_URI "/oic/gateway"
+ #endif
#ifdef WITH_PRESENCE
/** Presence URI through which the OIC devices advertise their presence.*/
#ifdef RA_ADAPTER
/**Remote Access over XMPP.*/
- OC_ADAPTER_REMOTE_ACCESS = (1 << 3)
+ OC_ADAPTER_REMOTE_ACCESS = (1 << 3),
+ #endif
+
+ #ifdef TCP_ADAPTER
+ /** CoAP over TCP.*/
+ OC_ADAPTER_TCP = (1 << 4)
#endif
} OCTransportAdapter;
/** transport modifiers.*/
OCTransportFlags flags;
+ /** for IP.*/
+ uint16_t port;
+
/** address for all adapters.*/
char addr[MAX_ADDR_STR_SIZE];
/** usually zero for default interface.*/
uint32_t interface;
-
- /** for IP.*/
- uint16_t port;
-
- /** secure node identity.*/
- OCIdentity identity;
+ #if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
+ char routeData[MAX_ADDR_STR_SIZE]; //destination GatewayID:ClientId
+ #endif
} OCDevAddr;
/**
/** RFCOMM over Bluetooth EDR.*/
CT_ADAPTER_RFCOMM_BTEDR = (1 << 18),
- #ifdef RA_ADAPTER
+ #ifdef RA_ADAPTER
/** Remote Access over XMPP.*/
CT_ADAPTER_REMOTE_ACCESS = (1 << 19),
- #endif
+ #endif
+
+ #ifdef TCP_ADAPTER
+ /** CoAP over TCP.*/
+ CT_ADAPTER_TCP = (1 << 20),
+ #endif
/** Insecure transport is the default (subject to change).*/
} OCMethod;
/**
+ * Formats for payload encoding.
+ */
+ typedef enum
+ {
+ OC_FORMAT_CBOR,
+ OC_FORMAT_UNDEFINED,
+ OC_FORMAT_UNSUPPORTED,
+ } OCPayloadFormat;
+
+ /**
* Host Mode of Operation.
*/
typedef enum
{
OC_CLIENT = 0,
OC_SERVER,
- OC_CLIENT_SERVER
+ OC_CLIENT_SERVER,
+ OC_GATEWAY /**< Client server mode along with routing capabilities.*/
} OCMode;
/**
/** Request is not authorized by Resource Server. */
OC_STACK_UNAUTHORIZED_REQ,
+ /** Error code from PDM */
+ OC_STACK_PDM_IS_NOT_INITIALIZED,
+ OC_STACK_DUPLICATE_UUID,
+ OC_STACK_INCONSISTENT_DB,
+
/** Insert all new error codes here!.*/
#ifdef WITH_PRESENCE
OC_STACK_PRESENCE_STOPPED = 128,
PAYLOAD_TYPE_PLATFORM,
PAYLOAD_TYPE_REPRESENTATION,
PAYLOAD_TYPE_SECURITY,
- PAYLOAD_TYPE_PRESENCE
+ PAYLOAD_TYPE_PRESENCE,
+ PAYLOAD_TYPE_RD
} OCPayloadType;
typedef struct
/** the payload from the request PDU.*/
OCPayload *payload;
-
} OCEntityHandlerRequest;
/** backward compatibility.*/
OCConnectivityType connType;
+ /** the security identity of the remote server.*/
+ OCIdentity identity;
+
/** the is the result of our stack, OCStackResult should contain coap/other error codes.*/
OCStackResult result;
#ifndef PAYLOAD_LOGGING_H_
#define PAYLOAD_LOGGING_H_
+ #include "logger.h"
+ #ifdef __TIZEN__
+ #include <dlog.h>
+ #endif
+
#ifdef __cplusplus
extern "C"
{
#endif
+ // PL_TAG is made as generic predefined tag because of build problems in arduino for using logging
+ #define PL_TAG "PayloadLog"
+
#ifdef TB_LOG
- #define OC_LOG_PAYLOAD(level, tag, payload) OCPayloadLog((level),(tag),(payload))
+ #define OC_LOG_PAYLOAD(level, payload) OCPayloadLog((level),(payload))
#define UUID_SIZE (16)
#define UUID_LENGTH (37)
const char *convertTriggerEnumToString(OCPresenceTrigger trigger);
OCPresenceTrigger convertTriggerStringToEnum(const char * triggerStr);
- static inline void OCPayloadLogRep(LogLevel level, const char* tag, OCRepPayload* payload)
+ static inline void OCPayloadLogRep(LogLevel level, OCRepPayload* payload)
{
- OC_LOG(level, tag, PCF("Payload Type: Representation"));
+ OC_LOG(level, (PL_TAG), "Payload Type: Representation");
OCRepPayload* rep = payload;
int i = 1;
while(rep)
{
- OC_LOG_V(level, tag, "\tResource #%d", i);
- OC_LOG_V(level, tag, "\tURI:%s", rep->uri);
- OC_LOG(level, tag, PCF("\tResource Types:"));
+ OC_LOG_V(level, PL_TAG, "\tResource #%d", i);
+ OC_LOG_V(level, PL_TAG, "\tURI:%s", rep->uri);
+ OC_LOG(level, PL_TAG, "\tResource Types:");
OCStringLL* strll = rep->types;
while(strll)
{
- OC_LOG_V(level, tag, "\t\t%s", strll->value);
+ OC_LOG_V(level, PL_TAG, "\t\t%s", strll->value);
strll = strll->next;
}
- OC_LOG(level, tag, PCF("\tInterfaces:"));
+ OC_LOG(level, PL_TAG, "\tInterfaces:");
strll = rep->interfaces;
while(strll)
{
- OC_LOG_V(level, tag, "\t\t%s", strll->value);
+ OC_LOG_V(level, PL_TAG, "\t\t%s", strll->value);
strll = strll->next;
}
// TODO Finish Logging: Values
OCRepPayloadValue* val = rep->values;
- OC_LOG(level, tag, PCF("\tValues:"));
+ OC_LOG(level, PL_TAG, "\tValues:");
while(val)
{
switch(val->type)
{
case OCREP_PROP_NULL:
- OC_LOG_V(level, tag, "\t\t%s: NULL", val->name);
+ OC_LOG_V(level, PL_TAG, "\t\t%s: NULL", val->name);
break;
case OCREP_PROP_INT:
- OC_LOG_V(level, tag, "\t\t%s(int):%lld", val->name, val->i);
+ OC_LOG_V(level, PL_TAG, "\t\t%s(int):%lld", val->name, val->i);
break;
case OCREP_PROP_DOUBLE:
- OC_LOG_V(level, tag, "\t\t%s(double):%f", val->name, val->d);
+ OC_LOG_V(level, PL_TAG, "\t\t%s(double):%f", val->name, val->d);
break;
case OCREP_PROP_BOOL:
- OC_LOG_V(level, tag, "\t\t%s(bool):%s", val->name, val->b ? "true" : "false");
+ OC_LOG_V(level, PL_TAG, "\t\t%s(bool):%s", val->name, val->b ? "true" : "false");
break;
case OCREP_PROP_STRING:
- OC_LOG_V(level, tag, "\t\t%s(string):%s", val->name, val->str);
+ OC_LOG_V(level, PL_TAG, "\t\t%s(string):%s", val->name, val->str);
break;
case OCREP_PROP_OBJECT:
// Note: Only prints the URI (if available), to print further, you'll
// need to dig into the object better!
- OC_LOG_V(level, tag, "\t\t%s(OCRep):%s", val->name, val->obj->uri);
+ OC_LOG_V(level, PL_TAG, "\t\t%s(OCRep):%s", val->name, val->obj->uri);
break;
case OCREP_PROP_ARRAY:
switch(val->arr.type)
{
case OCREP_PROP_INT:
- OC_LOG_V(level, tag, "\t\t%s(int array):%lld x %lld x %lld",
+ OC_LOG_V(level, PL_TAG, "\t\t%s(int array):%lld x %lld x %lld",
val->name,
val->arr.dimensions[0], val->arr.dimensions[1],
val->arr.dimensions[2]);
break;
case OCREP_PROP_DOUBLE:
- OC_LOG_V(level, tag, "\t\t%s(double array):%lld x %lld x %lld",
+ OC_LOG_V(level, PL_TAG, "\t\t%s(double array):%lld x %lld x %lld",
val->name,
val->arr.dimensions[0], val->arr.dimensions[1],
val->arr.dimensions[2]);
break;
case OCREP_PROP_BOOL:
- OC_LOG_V(level, tag, "\t\t%s(bool array):%lld x %lld x %lld",
+ OC_LOG_V(level, PL_TAG, "\t\t%s(bool array):%lld x %lld x %lld",
val->name,
val->arr.dimensions[0], val->arr.dimensions[1],
val->arr.dimensions[2]);
break;
case OCREP_PROP_STRING:
- OC_LOG_V(level, tag, "\t\t%s(string array):%lld x %lld x %lld",
+ OC_LOG_V(level, PL_TAG, "\t\t%s(string array):%lld x %lld x %lld",
val->name,
val->arr.dimensions[0], val->arr.dimensions[1],
val->arr.dimensions[2]);
break;
case OCREP_PROP_OBJECT:
- OC_LOG_V(level, tag, "\t\t%s(OCRep array):%lld x %lld x %lld",
+ OC_LOG_V(level, PL_TAG, "\t\t%s(OCRep array):%lld x %lld x %lld",
val->name,
val->arr.dimensions[0], val->arr.dimensions[1],
val->arr.dimensions[2]);
break;
default:
- OC_LOG_V(ERROR, tag, "\t\t%s <-- Unknown/unsupported array type!",
+ OC_LOG_V(ERROR, PL_TAG, "\t\t%s <-- Unknown/unsupported array type!",
val->name);
break;
}
break;
default:
- OC_LOG_V(ERROR, tag, "\t\t%s <-- Unknown type!", val->name);
+ OC_LOG_V(ERROR, PL_TAG, "\t\t%s <-- Unknown type!", val->name);
break;
}
val = val -> next;
}
- static inline void OCPayloadLogDiscovery(LogLevel level, const char* tag,
- OCDiscoveryPayload* payload)
+ static inline void OCPayloadLogDiscovery(LogLevel level, OCDiscoveryPayload* payload)
{
- OC_LOG(level, tag, PCF("Payload Type: Discovery"));
+ OC_LOG(level, PL_TAG, "Payload Type: Discovery");
int i = 1;
if(!payload->resources)
{
- OC_LOG(level, tag, PCF("\tNO Resources"));
+ OC_LOG(level, PL_TAG, "\tNO Resources");
return;
}
while(res)
{
- OC_LOG_V(level, tag, "\tResource #%d", i);
- OC_LOG_V(level, tag, "\tURI:%s", res->uri);
- OC_LOG(level, tag, PCF("\tSID:"));
- OC_LOG_BUFFER(level, tag, res->sid, UUID_SIZE);
- OC_LOG(level, tag, PCF("\tResource Types:"));
+ OC_LOG_V(level, PL_TAG, "\tResource #%d", i);
+ OC_LOG_V(level, PL_TAG, "\tURI:%s", res->uri);
+ OC_LOG(level, PL_TAG, "\tSID:");
+ OC_LOG_BUFFER(level, PL_TAG, res->sid, UUID_SIZE);
+ OC_LOG(level, PL_TAG, "\tResource Types:");
OCStringLL* strll = res->types;
while(strll)
{
- OC_LOG_V(level, tag, "\t\t%s", strll->value);
+ OC_LOG_V(level, PL_TAG, "\t\t%s", strll->value);
strll = strll->next;
}
- OC_LOG(level, tag, PCF("\tInterfaces:"));
+ OC_LOG(level, PL_TAG, "\tInterfaces:");
strll = res->interfaces;
while(strll)
{
- OC_LOG_V(level, tag, "\t\t%s", strll->value);
+ OC_LOG_V(level, PL_TAG, "\t\t%s", strll->value);
strll = strll->next;
}
- OC_LOG_V(level, tag, "\tBitmap: %u", res->bitmap);
- OC_LOG_V(level, tag, "\tSecure?: %s", res->secure ? "true" : "false");
- OC_LOG_V(level, tag, "\tPort: %u", res->port);
- OC_LOG(level, tag, PCF(""));
+ OC_LOG_V(level, PL_TAG, "\tBitmap: %u", res->bitmap);
+ OC_LOG_V(level, PL_TAG, "\tSecure?: %s", res->secure ? "true" : "false");
+ OC_LOG_V(level, PL_TAG, "\tPort: %u", res->port);
+ OC_LOG(level, PL_TAG, "");
res = res->next;
++i;
}
}
- static inline void OCPayloadLogDevice(LogLevel level, const char* tag, OCDevicePayload* payload)
+ static inline void OCPayloadLogDevice(LogLevel level, OCDevicePayload* payload)
{
- OC_LOG(level, tag, PCF("Payload Type: Device"));
- OC_LOG_V(level, tag, "\tURI:%s", payload->uri);
- OC_LOG(level, tag, PCF("\tSID:"));
- OC_LOG_BUFFER(level, tag, payload->sid, UUID_SIZE);
- OC_LOG_V(level, tag, "\tDevice Name:%s", payload->deviceName);
- OC_LOG_V(level, tag, "\tSpec Version%s", payload->specVersion);
- OC_LOG_V(level, tag, "\tData Model Version:%s", payload->dataModelVersion);
+ OC_LOG(level, PL_TAG, "Payload Type: Device");
+ OC_LOG_V(level, PL_TAG, "\tURI:%s", payload->uri);
+ OC_LOG(level, PL_TAG, "\tSID:");
+ OC_LOG_BUFFER(level, PL_TAG, payload->sid, UUID_SIZE);
+ OC_LOG_V(level, PL_TAG, "\tDevice Name:%s", payload->deviceName);
+ OC_LOG_V(level, PL_TAG, "\tSpec Version%s", payload->specVersion);
+ OC_LOG_V(level, PL_TAG, "\tData Model Version:%s", payload->dataModelVersion);
}
- static inline void OCPayloadLogPlatform(LogLevel level, const char* tag, OCPlatformPayload* payload)
+ static inline void OCPayloadLogPlatform(LogLevel level, OCPlatformPayload* payload)
{
- OC_LOG(level, tag, PCF("Payload Type: Platform"));
- OC_LOG_V(level, tag, "\tURI:%s", payload->uri);
- OC_LOG_V(level, tag, "\tPlatform ID:%s", payload->info.platformID);
- OC_LOG_V(level, tag, "\tMfg Name:%s", payload->info.manufacturerName);
- OC_LOG_V(level, tag, "\tMfg URL:%s", payload->info.manufacturerUrl);
- OC_LOG_V(level, tag, "\tModel Number:%s", payload->info.modelNumber);
- OC_LOG_V(level, tag, "\tDate of Mfg:%s", payload->info.dateOfManufacture);
- OC_LOG_V(level, tag, "\tPlatform Version:%s", payload->info.platformVersion);
- OC_LOG_V(level, tag, "\tOS Version:%s", payload->info.operatingSystemVersion);
- OC_LOG_V(level, tag, "\tHardware Version:%s", payload->info.hardwareVersion);
- OC_LOG_V(level, tag, "\tFirmware Version:%s", payload->info.firmwareVersion);
- OC_LOG_V(level, tag, "\tSupport URL:%s", payload->info.supportUrl);
- OC_LOG_V(level, tag, "\tSystem Time:%s", payload->info.systemTime);
+ OC_LOG(level, PL_TAG, "Payload Type: Platform");
+ OC_LOG_V(level, PL_TAG, "\tURI:%s", payload->uri);
+ OC_LOG_V(level, PL_TAG, "\tPlatform ID:%s", payload->info.platformID);
+ OC_LOG_V(level, PL_TAG, "\tMfg Name:%s", payload->info.manufacturerName);
+ OC_LOG_V(level, PL_TAG, "\tMfg URL:%s", payload->info.manufacturerUrl);
+ OC_LOG_V(level, PL_TAG, "\tModel Number:%s", payload->info.modelNumber);
+ OC_LOG_V(level, PL_TAG, "\tDate of Mfg:%s", payload->info.dateOfManufacture);
+ OC_LOG_V(level, PL_TAG, "\tPlatform Version:%s", payload->info.platformVersion);
+ OC_LOG_V(level, PL_TAG, "\tOS Version:%s", payload->info.operatingSystemVersion);
+ OC_LOG_V(level, PL_TAG, "\tHardware Version:%s", payload->info.hardwareVersion);
+ OC_LOG_V(level, PL_TAG, "\tFirmware Version:%s", payload->info.firmwareVersion);
+ OC_LOG_V(level, PL_TAG, "\tSupport URL:%s", payload->info.supportUrl);
+ OC_LOG_V(level, PL_TAG, "\tSystem Time:%s", payload->info.systemTime);
}
- static inline void OCPayloadLogPresence(LogLevel level, const char* tag, OCPresencePayload* payload)
+ static inline void OCPayloadLogPresence(LogLevel level, OCPresencePayload* payload)
{
- OC_LOG(level, tag, PCF("Payload Type: Presence"));
- OC_LOG_V(level, tag, "\tSequence Number:%u", payload->sequenceNumber);
- OC_LOG_V(level, tag, "\tMax Age:%d", payload->maxAge);
- OC_LOG_V(level, tag, "\tTrigger:%s", convertTriggerEnumToString(payload->trigger));
- OC_LOG_V(level, tag, "\tResource Type:%s", payload->resourceType);
+ OC_LOG(level, PL_TAG, "Payload Type: Presence");
+ OC_LOG_V(level, PL_TAG, "\tSequence Number:%u", payload->sequenceNumber);
+ OC_LOG_V(level, PL_TAG, "\tMax Age:%d", payload->maxAge);
+ OC_LOG_V(level, PL_TAG, "\tTrigger:%s", convertTriggerEnumToString(payload->trigger));
+ OC_LOG_V(level, PL_TAG, "\tResource Type:%s", payload->resourceType);
}
- static inline void OCPayloadLogSecurity(LogLevel level, const char* tag,
- OCSecurityPayload* payload)
+ static inline void OCPayloadLogSecurity(LogLevel level, OCSecurityPayload* payload)
{
- OC_LOG(level, tag, PCF("Payload Type: Security"));
- OC_LOG_V(level, tag, "\tSecurity Data: %s", payload->securityData);
+ OC_LOG(level, PL_TAG, "Payload Type: Security");
+ OC_LOG_V(level, PL_TAG, "\tSecurity Data: %s", payload->securityData);
}
- static inline void OCPayloadLog(LogLevel level, const char* tag, OCPayload* payload)
+ static inline void OCPayloadLog(LogLevel level, OCPayload* payload)
{
if(!payload)
{
- OC_LOG(level, tag, PCF("NULL Payload"));
+ OC_LOG(level, PL_TAG, "NULL Payload");
return;
}
switch(payload->type)
{
case PAYLOAD_TYPE_REPRESENTATION:
- OCPayloadLogRep(level, tag, (OCRepPayload*)payload);
+ OCPayloadLogRep(level, (OCRepPayload*)payload);
break;
case PAYLOAD_TYPE_DISCOVERY:
- OCPayloadLogDiscovery(level, tag, (OCDiscoveryPayload*)payload);
+ OCPayloadLogDiscovery(level, (OCDiscoveryPayload*)payload);
break;
case PAYLOAD_TYPE_DEVICE:
- OCPayloadLogDevice(level, tag, (OCDevicePayload*)payload);
+ OCPayloadLogDevice(level, (OCDevicePayload*)payload);
break;
case PAYLOAD_TYPE_PLATFORM:
- OCPayloadLogPlatform(level, tag, (OCPlatformPayload*)payload);
+ OCPayloadLogPlatform(level, (OCPlatformPayload*)payload);
break;
case PAYLOAD_TYPE_PRESENCE:
- OCPayloadLogPresence(level, tag, (OCPresencePayload*)payload);
+ OCPayloadLogPresence(level, (OCPresencePayload*)payload);
break;
case PAYLOAD_TYPE_SECURITY:
- OCPayloadLogSecurity(level, tag, (OCSecurityPayload*)payload);
+ OCPayloadLogSecurity(level, (OCSecurityPayload*)payload);
break;
+#ifdef WITH_RD
+ case PAYLOAD_TYPE_RD:
+ OCRDPayloadLog(level, tag, (OCRDPayload*)payload);
+ break;
+#endif
default:
- OC_LOG_V(level, tag, "Unknown Payload Type: %d", payload->type);
+ OC_LOG_V(level, PL_TAG, "Unknown Payload Type: %d", payload->type);
break;
}
}
#else
- #define OC_LOG_PAYLOAD(level, tag, payload)
+ #define OC_LOG_PAYLOAD(level, payload)
#endif
#ifdef __cplusplus
case PAYLOAD_TYPE_SECURITY:
OCSecurityPayloadDestroy((OCSecurityPayload*)payload);
break;
+#ifdef WITH_RD
+ case PAYLOAD_TYPE_RD:
+ OCRDPayloadDestroy((OCRDPayload*)payload);
+ break;
+#endif
default:
OC_LOG_V(ERROR, TAG, "Unsupported payload type in destroy: %d", payload->type);
OICFree(payload);
static void OCCopyPropertyValueArray(OCRepPayloadValue* dest, OCRepPayloadValue* source)
{
+ if(!dest || !source)
+ {
+ return;
+ }
+
size_t dimTotal = calcDimTotal(source->arr.dimensions);
switch(source->arr.type)
{
}
break;
default:
- OC_LOG(ERROR, TAG, PCF("CopyPropertyValueArray invalid type"));
+ OC_LOG(ERROR, TAG, "CopyPropertyValueArray invalid type");
break;
}
}
val = val->next;
}
- OC_LOG(ERROR, TAG, PCF("FindAndSetValue reached point after while loop, pointer corruption?"));
+ OC_LOG(ERROR, TAG, "FindAndSetValue reached point after while loop, pointer corruption?");
return NULL;
}
return val->type == OCREP_PROP_NULL;
}
- bool OCRepPayloadSetNull(OCRepPayload* payload, const char* name)
+ static bool OCRepPayloadSetProp(OCRepPayload* payload, const char* name,
+ void* value, OCRepPayloadPropType type)
{
- OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_NULL);
- return val != NULL;
- }
-
- bool OCRepPayloadSetPropInt(OCRepPayload* payload,
- const char* name, int64_t value)
- {
- OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_INT);
-
+ OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, type);
if(!val)
{
return false;
}
+ switch(type)
+ {
+ case OCREP_PROP_INT:
+ val->i = *(int64_t*)value;
+ break;
+ case OCREP_PROP_DOUBLE:
+ val->d = *(double*)value;
+ break;
+ case OCREP_PROP_BOOL:
+ val->b = *(bool*)value;
+ break;
+ case OCREP_PROP_OBJECT:
+ val->obj = (OCRepPayload*)value;
+ break;
+ case OCREP_PROP_STRING:
+ val->str = (char*)value;
+ return val->str != NULL;
+ case OCREP_PROP_NULL:
+ return val != NULL;
+ case OCREP_PROP_ARRAY:
+ default:
+ return false;
+ }
- val->i = value;
return true;
}
+ bool OCRepPayloadSetNull(OCRepPayload* payload, const char* name)
+ {
+ return OCRepPayloadSetProp(payload, name, NULL, OCREP_PROP_NULL);
+ }
+
+ bool OCRepPayloadSetPropInt(OCRepPayload* payload,
+ const char* name, int64_t value)
+ {
+ return OCRepPayloadSetProp(payload, name, &value, OCREP_PROP_INT);
+ }
+
bool OCRepPayloadGetPropInt(const OCRepPayload* payload, const char* name, int64_t* value)
{
OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
bool OCRepPayloadSetPropDouble(OCRepPayload* payload,
const char* name, double value)
{
- OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_DOUBLE);
-
- if(!val )
- {
- return false;
- }
-
- val->d = value;
- return true;
+ return OCRepPayloadSetProp(payload, name, &value, OCREP_PROP_DOUBLE);
}
bool OCRepPayloadGetPropDouble(const OCRepPayload* payload, const char* name, double* value)
bool OCRepPayloadSetPropStringAsOwner(OCRepPayload* payload, const char* name, char* value)
{
- OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_STRING);
-
- if(!val)
- {
- return false;
- }
-
- val->str = value;
- return val->str != NULL;
+ return OCRepPayloadSetProp(payload, name, value, OCREP_PROP_STRING);
}
- bool OCRepPayloadGetPropString(const OCRepPayload* payload, const char* name, const char** value)
+ bool OCRepPayloadGetPropString(const OCRepPayload* payload, const char* name, char** value)
{
OCRepPayloadValue* val = OCRepPayloadFindValue(payload, name);
bool OCRepPayloadSetPropBool(OCRepPayload* payload,
const char* name, bool value)
{
- OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_BOOL);
-
- if(!val)
- {
- return false;
- }
-
- val->b = value;
- return true;
+ return OCRepPayloadSetProp(payload, name, &value, OCREP_PROP_BOOL);
}
bool OCRepPayloadGetPropBool(const OCRepPayload* payload, const char* name, bool* value)
bool OCRepPayloadSetPropObjectAsOwner(OCRepPayload* payload, const char* name, OCRepPayload* value)
{
- OCRepPayloadValue* val = OCRepPayloadFindAndSetValue(payload, name, OCREP_PROP_OBJECT);
-
- if(!val)
- {
- return false;
- }
-
- val->obj = value;
- return true;
+ return OCRepPayloadSetProp(payload, name, value, OCREP_PROP_OBJECT);
}
bool OCRepPayloadGetPropObject(const OCRepPayload* payload, const char* name, OCRepPayload** value)
OCStringLL* cur = pl->interfaces;
ifPtr = ifPtr->next;
- while(ifPtr)
+ while(ifPtr && cur)
{
cur->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
if(!cur->next)
static void OCCopyPlatformInfo(const OCPlatformInfo* platformInfo, OCPlatformPayload* target)
{
+ if(!platformInfo || !target)
+ {
+ return;
+ }
+
target->info.platformID = OICStrdup(platformInfo->platformID);
target->info.manufacturerName = OICStrdup(platformInfo->manufacturerName);
target->info.manufacturerUrl = OICStrdup(platformInfo->manufacturerUrl);
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#include "ocpayloadcbor.h"
+ #include "platform_features.h"
#include <stdlib.h>
#include "oic_malloc.h"
#include "logger.h"
#include "ocresourcehandler.h"
#include "cbor.h"
- #define TAG PCF("OCPayloadConvert")
+ #define TAG "OCPayloadConvert"
+ // Arbitrarily chosen size that seems to contain the majority of packages
+ #define INIT_SIZE (255)
- static OCStackResult OCConvertDiscoveryPayload(OCDiscoveryPayload* payload, uint8_t** outPayload,
+ // Functions all return either a CborError, or a negative version of the OC_STACK return values
+ static int64_t OCConvertPayloadHelper(OCPayload* payload, uint8_t* outPayload, size_t* size);
+ static int64_t OCConvertDiscoveryPayload(OCDiscoveryPayload* payload, uint8_t* outPayload,
size_t* size);
- static OCStackResult OCConvertDevicePayload(OCDevicePayload* payload, uint8_t** outPayload,
+ static int64_t OCConvertDevicePayload(OCDevicePayload* payload, uint8_t* outPayload,
size_t* size);
- static OCStackResult OCConvertPlatformPayload(OCPlatformPayload* payload, uint8_t** outPayload,
+ static int64_t OCConvertPlatformPayload(OCPlatformPayload* payload, uint8_t* outPayload,
size_t* size);
- static OCStackResult OCConvertRepPayload(OCRepPayload* payload, uint8_t** outPayload, size_t* size);
- static OCStackResult OCConvertPresencePayload(OCPresencePayload* payload, uint8_t** outPayload,
+ static int64_t OCConvertRepPayload(OCRepPayload* payload, uint8_t* outPayload, size_t* size);
+ static int64_t OCConvertPresencePayload(OCPresencePayload* payload, uint8_t* outPayload,
size_t* size);
- static OCStackResult OCConvertSecurityPayload(OCSecurityPayload* payload, uint8_t** outPayload,
+ static int64_t OCConvertSecurityPayload(OCSecurityPayload* payload, uint8_t* outPayload,
size_t* size);
+ static int64_t OCConvertSingleRepPayload(CborEncoder* parent, const OCRepPayload* payload);
+ static int64_t OCConvertArray(CborEncoder* parent, const OCRepPayloadValueArray* valArray);
- bool AddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
+ static int64_t AddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
const char* value);
- bool ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
+ static int64_t ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
const char* value);
-
OCStackResult OCConvertPayload(OCPayload* payload, uint8_t** outPayload, size_t* size)
{
+ // TinyCbor Version 47a78569c0 or better on master is required for the re-allocation
+ // strategy to work. If you receive the following assertion error, please do a git-pull
+ // from the extlibs/tinycbor/tinycbor directory
+ #define CborNeedsUpdating (CborErrorOutOfMemory < CborErrorDataTooLarge)
+ OC_STATIC_ASSERT(!CborNeedsUpdating, "tinycbor needs to be updated to at least 47a78569c0");
+ #undef CborNeedsUpdating
+ if (!payload)
+ {
+ OC_LOG(ERROR, TAG, "Payload parameter NULL");
+ return OC_STACK_INVALID_PARAM;
+ }
+
+ if (!outPayload || !size)
+ {
+ OC_LOG(ERROR, TAG, "Out parameter/s parameter NULL");
+ return OC_STACK_INVALID_PARAM;
+ }
+
OC_LOG_V(INFO, TAG, "Converting payload of type %d", payload->type);
+
+ size_t curSize = INIT_SIZE;
+ uint8_t* out = (uint8_t*)OICCalloc(1, curSize);
+ int64_t err = OCConvertPayloadHelper(payload, out, &curSize);
+
+ if (err == CborErrorOutOfMemory)
+ {
+ // reallocate "out" and try again!
+ uint8_t* out2 = (uint8_t*)OICRealloc(out, curSize);
+
+ if (!out2)
+ {
+ OICFree(out);
+ return OC_STACK_NO_MEMORY;
+ }
+
+ out = out2;
+ err = OCConvertPayloadHelper(payload, out, &curSize);
+ }
+
+ if (err == 0)
+ {
+ if (curSize < INIT_SIZE)
+ {
+ uint8_t* out2 = (uint8_t*)OICRealloc(out, curSize);
+
+ if (!out2)
+ {
+ OICFree(out);
+ return OC_STACK_NO_MEMORY;
+ }
+
+ out = out2;
+ }
+
+ *size = curSize;
+ *outPayload = out;
+ return OC_STACK_OK;
+ }
+ else if (err < 0)
+ {
+ return (OCStackResult)-err;
+ }
+ else
+ {
+ return OC_STACK_ERROR;
+ }
+ }
+
+ static int64_t OCConvertPayloadHelper(OCPayload* payload, uint8_t* outPayload, size_t* size)
+ {
switch(payload->type)
{
case PAYLOAD_TYPE_DISCOVERY:
return OCConvertPresencePayload((OCPresencePayload*)payload, outPayload, size);
case PAYLOAD_TYPE_SECURITY:
return OCConvertSecurityPayload((OCSecurityPayload*)payload, outPayload, size);
+#ifdef WITH_RD
+ case PAYLOAD_TYPE_RD:
+ return OCRDPayloadToCbor((OCRDPayload*)payload, outPayload, size);
+#endif
default:
OC_LOG_V(INFO,TAG, "ConvertPayload default %d", payload->type);
return OC_STACK_NOTIMPL;
}
}
- static OCStackResult OCConvertSecurityPayload(OCSecurityPayload* payload, uint8_t** outPayload,
- size_t* size)
+ static int64_t checkError(int64_t err, CborEncoder* encoder, uint8_t* outPayload, size_t* size)
{
- *outPayload = (uint8_t*)OICCalloc(1, MAX_REQUEST_LENGTH);
- *size = MAX_REQUEST_LENGTH;
-
- if(!*outPayload)
+ if (err == CborErrorOutOfMemory)
{
- return OC_STACK_NO_MEMORY;
+ *size += encoder->ptr - encoder->end;
+ return err;
}
-
+ else if (err != 0)
+ {
+ OC_LOG_V(ERROR, TAG, "Convert Payload failed", err);
+ return err;
+ }
+ else
+ {
+ *size = encoder->ptr - outPayload;
+ return 0;
+ }
+ }
+ static int64_t OCConvertSecurityPayload(OCSecurityPayload* payload, uint8_t* outPayload,
+ size_t* size)
+ {
CborEncoder encoder;
- bool err = false;
+ int64_t err = 0;
- cbor_encoder_init(&encoder, *outPayload, *size, 0);
+ cbor_encoder_init(&encoder, outPayload, *size, 0);
CborEncoder rootArray;
- err = err || cbor_encoder_create_array(&encoder, &rootArray, 2);
- err = err || cbor_encode_uint(&rootArray, PAYLOAD_TYPE_SECURITY);
-
+ err = err | cbor_encoder_create_array(&encoder, &rootArray, 1);
CborEncoder map;
- err = err || cbor_encoder_create_map(&rootArray, &map, CborIndefiniteLength);
+ err = err | cbor_encoder_create_map(&rootArray, &map, CborIndefiniteLength);
if(payload->securityData)
{
- err = err || AddTextStringToMap(&map, OC_RSRVD_REPRESENTATION,
+ err = err | AddTextStringToMap(&map, OC_RSRVD_REPRESENTATION,
sizeof(OC_RSRVD_REPRESENTATION) - 1,
payload->securityData);
}
- err = err || cbor_encoder_close_container(&rootArray, &map);
-
- err = err || cbor_encoder_close_container(&encoder, &rootArray);
-
- if(err)
- {
- OC_LOG_V(ERROR, TAG, "Convert Security Payload failed", err);
- OICFree(*outPayload);
- return OC_STACK_ERROR;
- }
-
- *size = encoder.ptr - *outPayload;
- uint8_t* tempPayload = (uint8_t*)OICRealloc(*outPayload, *size);
+ err = err | cbor_encoder_close_container(&rootArray, &map);
- if(!tempPayload)
- {
- OC_LOG_V(ERROR, TAG, PCF("Payload realloc failed!"));
- OICFree(*outPayload);
- return OC_STACK_ERROR;
- }
+ err = err | cbor_encoder_close_container(&encoder, &rootArray);
+ return checkError(err, &encoder, outPayload, size);
- *outPayload = tempPayload;
- return OC_STACK_OK;
}
- static OCStackResult OCConvertDiscoveryPayload(OCDiscoveryPayload* payload, uint8_t** outPayload,
+ static int64_t OCConvertDiscoveryPayload(OCDiscoveryPayload* payload, uint8_t* outPayload,
size_t* size)
{
- *outPayload = (uint8_t*)OICCalloc(1, MAX_REQUEST_LENGTH);
- *size = MAX_REQUEST_LENGTH;
-
- if(!*outPayload)
- {
- return OC_STACK_NO_MEMORY;
- }
-
CborEncoder encoder = {0};
- bool err = false;
+ int64_t err = 0;
size_t resourceCount = OCDiscoveryPayloadGetResourceCount(payload);
- cbor_encoder_init(&encoder, *outPayload, *size, 0);
+ cbor_encoder_init(&encoder, outPayload, *size, 0);
CborEncoder rootArray;
- err = err || cbor_encoder_create_array(&encoder, &rootArray, 1 + resourceCount);
- err = err || cbor_encode_uint(&rootArray, PAYLOAD_TYPE_DISCOVERY);
+ err = err | cbor_encoder_create_array(&encoder, &rootArray, resourceCount);
for(size_t i = 0; i < resourceCount; ++i)
{
if(!resource)
{
- OICFree(*outPayload);
return OC_STACK_INVALID_PARAM;
}
- err = err || cbor_encoder_create_map(&rootArray, &map, 3);
+ err = err | cbor_encoder_create_map(&rootArray, &map, 3);
// Uri
- err = err || AddTextStringToMap(&map, OC_RSRVD_HREF,
+ err = err | AddTextStringToMap(&map, OC_RSRVD_HREF,
sizeof(OC_RSRVD_HREF) - 1,
resource->uri);
// Server ID
- err = err || cbor_encode_text_string(&map, OC_RSRVD_SERVER_INSTANCE_ID,
+ err = err | cbor_encode_text_string(&map, OC_RSRVD_SERVER_INSTANCE_ID,
sizeof(OC_RSRVD_SERVER_INSTANCE_ID) - 1);
- err = err || cbor_encode_byte_string(&map, resource->sid, UUID_SIZE);
+ err = err | cbor_encode_byte_string(&map, resource->sid, UUID_SIZE);
// Prop Tag
{
CborEncoder propMap;
- err = err || cbor_encode_text_string(&map, OC_RSRVD_PROPERTY,
+ err = err | cbor_encode_text_string(&map, OC_RSRVD_PROPERTY,
sizeof(OC_RSRVD_PROPERTY) -1 );
- err = err || cbor_encoder_create_map(&map, &propMap, 3);
+ err = err | cbor_encoder_create_map(&map, &propMap, 3);
// Resource Type
{
CborEncoder rtArray;
- err = err || cbor_encode_text_string(&propMap, OC_RSRVD_RESOURCE_TYPE,
+ err = err | cbor_encode_text_string(&propMap, OC_RSRVD_RESOURCE_TYPE,
sizeof(OC_RSRVD_RESOURCE_TYPE) - 1);
- err = err || cbor_encoder_create_array(&propMap, &rtArray, CborIndefiniteLength);
+ err = err | cbor_encoder_create_array(&propMap, &rtArray, CborIndefiniteLength);
OCStringLL* rtPtr = resource->types;
while(rtPtr)
{
- err = err || cbor_encode_text_string(&rtArray, rtPtr->value,
+ err = err | cbor_encode_text_string(&rtArray, rtPtr->value,
strlen(rtPtr->value));
rtPtr = rtPtr->next;
}
- err = err || cbor_encoder_close_container(&propMap, &rtArray);
+ err = err | cbor_encoder_close_container(&propMap, &rtArray);
}
// Interface Types
{
CborEncoder ifArray;
- err = err || cbor_encode_text_string(&propMap, OC_RSRVD_INTERFACE,
+ err = err | cbor_encode_text_string(&propMap, OC_RSRVD_INTERFACE,
sizeof(OC_RSRVD_INTERFACE) - 1);
- err = err || cbor_encoder_create_array(&propMap, &ifArray, CborIndefiniteLength);
+ err = err | cbor_encoder_create_array(&propMap, &ifArray, CborIndefiniteLength);
OCStringLL* ifPtr = resource->interfaces;
while(ifPtr)
{
- err = err || cbor_encode_text_string(&ifArray, ifPtr->value,
+ err = err | cbor_encode_text_string(&ifArray, ifPtr->value,
strlen(ifPtr->value));
ifPtr= ifPtr->next;
}
- err = err || cbor_encoder_close_container(&propMap, &ifArray);
+ err = err | cbor_encoder_close_container(&propMap, &ifArray);
}
// Policy
{
CborEncoder policyMap;
- err = err || cbor_encode_text_string(&propMap, OC_RSRVD_POLICY,
+ err = err | cbor_encode_text_string(&propMap, OC_RSRVD_POLICY,
sizeof(OC_RSRVD_POLICY) - 1);
- err = err || cbor_encoder_create_map(&propMap, &policyMap, CborIndefiniteLength);
+ err = err | cbor_encoder_create_map(&propMap, &policyMap, CborIndefiniteLength);
// Bitmap
- err = err || cbor_encode_text_string(&policyMap, OC_RSRVD_BITMAP,
+ err = err | cbor_encode_text_string(&policyMap, OC_RSRVD_BITMAP,
sizeof(OC_RSRVD_BITMAP) - 1);
- err = err || cbor_encode_uint(&policyMap, resource->bitmap);
+ err = err | cbor_encode_uint(&policyMap, resource->bitmap);
if(resource->secure)
{
- err = err || cbor_encode_text_string(&policyMap, OC_RSRVD_SECURE,
+ err = err | cbor_encode_text_string(&policyMap, OC_RSRVD_SECURE,
sizeof(OC_RSRVD_SECURE) - 1);
- err = err || cbor_encode_boolean(&policyMap, OC_RESOURCE_SECURE);
+ err = err | cbor_encode_boolean(&policyMap, OC_RESOURCE_SECURE);
if(resource->port != 0)
{
- err = err || cbor_encode_text_string(&policyMap, OC_RSRVD_HOSTING_PORT,
+ err = err | cbor_encode_text_string(&policyMap, OC_RSRVD_HOSTING_PORT,
sizeof(OC_RSRVD_HOSTING_PORT) - 1);
- err = err || cbor_encode_uint(&policyMap, resource->port);
+ err = err | cbor_encode_uint(&policyMap, resource->port);
}
}
- err = err || cbor_encoder_close_container(&propMap, &policyMap);
+ err = err | cbor_encoder_close_container(&propMap, &policyMap);
}
// Close
- err = err || cbor_encoder_close_container(&map, &propMap);
+ err = err | cbor_encoder_close_container(&map, &propMap);
}
// Close Item
- err = err || cbor_encoder_close_container(&rootArray, &map);
+ err = err | cbor_encoder_close_container(&rootArray, &map);
}
// Close main array
- err = err || cbor_encoder_close_container(&encoder, &rootArray);
-
- if(err)
- {
- OC_LOG_V(ERROR, TAG, "Convert Discovery Payload failed with : %d", err);
- return OC_STACK_ERROR;
- }
-
- *size = encoder.ptr - *outPayload;
- uint8_t* tempPayload = (uint8_t*)OICRealloc(*outPayload, *size);
-
- if(!tempPayload)
- {
- OC_LOG_V(ERROR, TAG, PCF("Payload realloc failed!"));
- OICFree(*outPayload);
- return OC_STACK_ERROR;
- }
+ err = err | cbor_encoder_close_container(&encoder, &rootArray);
- *outPayload = tempPayload;
- return OC_STACK_OK;
+ return checkError(err, &encoder, outPayload, size);
}
- static OCStackResult OCConvertDevicePayload(OCDevicePayload* payload, uint8_t** outPayload,
+ static int64_t OCConvertDevicePayload(OCDevicePayload* payload, uint8_t* outPayload,
size_t* size)
{
- *outPayload = (uint8_t*)OICCalloc(1, MAX_REQUEST_LENGTH);
- *size = MAX_REQUEST_LENGTH;
-
- if(!*outPayload)
- {
- return OC_STACK_NO_MEMORY;
- }
-
CborEncoder encoder = {0};
- bool err = false;
+ int64_t err = 0;
- cbor_encoder_init(&encoder, *outPayload, *size, 0);
+ cbor_encoder_init(&encoder, outPayload, *size, 0);
CborEncoder rootArray;
- err = err || cbor_encoder_create_array(&encoder, &rootArray, 2);
- err = err || cbor_encode_uint(&rootArray, PAYLOAD_TYPE_DEVICE);
+ err = err | cbor_encoder_create_array(&encoder, &rootArray, 1);
{
CborEncoder map;
- err = err || cbor_encoder_create_map(&rootArray, &map, 2);
+ err = err | cbor_encoder_create_map(&rootArray, &map, 2);
// uri
- err = err || AddTextStringToMap(&map, OC_RSRVD_HREF, sizeof(OC_RSRVD_HREF) - 1,
+ err = err | AddTextStringToMap(&map, OC_RSRVD_HREF, sizeof(OC_RSRVD_HREF) - 1,
payload->uri);
// Rep Map
{
CborEncoder repMap;
- err = err || cbor_encode_text_string(&map, OC_RSRVD_REPRESENTATION,
+ err = err | cbor_encode_text_string(&map, OC_RSRVD_REPRESENTATION,
sizeof(OC_RSRVD_REPRESENTATION) - 1);
- err = err || cbor_encoder_create_map(&map, &repMap, 4);
+ err = err | cbor_encoder_create_map(&map, &repMap, 4);
// Device ID
- err = err || cbor_encode_text_string(&repMap, OC_RSRVD_DEVICE_ID,
+ err = err | cbor_encode_text_string(&repMap, OC_RSRVD_DEVICE_ID,
sizeof(OC_RSRVD_DEVICE_ID) - 1);
- err = err || cbor_encode_byte_string(&repMap, payload->sid, UUID_SIZE);
+ err = err | cbor_encode_byte_string(&repMap, payload->sid, UUID_SIZE);
// Device Name
- err = err || AddTextStringToMap(&repMap, OC_RSRVD_DEVICE_NAME,
+ err = err | AddTextStringToMap(&repMap, OC_RSRVD_DEVICE_NAME,
sizeof(OC_RSRVD_DEVICE_NAME) - 1,
payload->deviceName);
// Device Spec Version
- err = err || AddTextStringToMap(&repMap, OC_RSRVD_SPEC_VERSION,
+ err = err | AddTextStringToMap(&repMap, OC_RSRVD_SPEC_VERSION,
sizeof(OC_RSRVD_SPEC_VERSION) - 1,
payload->specVersion);
// Device data Model Version
- err = err || AddTextStringToMap(&repMap, OC_RSRVD_DATA_MODEL_VERSION,
+ err = err | AddTextStringToMap(&repMap, OC_RSRVD_DATA_MODEL_VERSION,
sizeof(OC_RSRVD_DATA_MODEL_VERSION) - 1,
payload->dataModelVersion);
- err = err || cbor_encoder_close_container(&map, &repMap);
+ err = err | cbor_encoder_close_container(&map, &repMap);
}
// Close Map
- err = err || cbor_encoder_close_container(&rootArray, &map);
+ err = err | cbor_encoder_close_container(&rootArray, &map);
}
// Close main array
- err = err || cbor_encoder_close_container(&encoder, &rootArray);
+ err = err | cbor_encoder_close_container(&encoder, &rootArray);
- if(err)
- {
- OC_LOG_V(ERROR, TAG, "Convert Device Payload failed with : %d", err);
- return OC_STACK_ERROR;
- }
-
- *size = encoder.ptr - *outPayload;
- uint8_t* tempPayload = (uint8_t*)OICRealloc(*outPayload, *size);
-
- if(!tempPayload)
- {
- OC_LOG_V(ERROR, TAG, PCF("Payload realloc failed!"));
- OICFree(*outPayload);
- return OC_STACK_ERROR;
- }
-
- *outPayload = tempPayload;
- return OC_STACK_OK;
+ return checkError(err, &encoder, outPayload, size);
}
- static OCStackResult OCConvertPlatformPayload(OCPlatformPayload* payload, uint8_t** outPayload,
+ static int64_t OCConvertPlatformPayload(OCPlatformPayload* payload, uint8_t* outPayload,
size_t* size)
{
- *outPayload = (uint8_t*)OICCalloc(1, MAX_REQUEST_LENGTH);
- *size = MAX_REQUEST_LENGTH;
-
- if(!*outPayload)
- {
- return OC_STACK_NO_MEMORY;
- }
-
CborEncoder encoder = {0};
- bool err = false;
+ int64_t err = 0;
- cbor_encoder_init(&encoder, *outPayload, *size, 0);
+ cbor_encoder_init(&encoder, outPayload, *size, 0);
CborEncoder rootArray;
- err = err || cbor_encoder_create_array(&encoder, &rootArray, 2);
- err = err || cbor_encode_uint(&rootArray, PAYLOAD_TYPE_PLATFORM);
+ err = err | cbor_encoder_create_array(&encoder, &rootArray, 1);
{
CborEncoder map;
- err = err || cbor_encoder_create_map(&rootArray, &map, CborIndefiniteLength);
+ err = err | cbor_encoder_create_map(&rootArray, &map, CborIndefiniteLength);
// uri
- err = err || AddTextStringToMap(&map, OC_RSRVD_HREF, sizeof(OC_RSRVD_HREF) - 1,
+ err = err | AddTextStringToMap(&map, OC_RSRVD_HREF, sizeof(OC_RSRVD_HREF) - 1,
payload->uri);
// Rep Map
{
CborEncoder repMap;
- err = err || cbor_encode_text_string(&map, OC_RSRVD_REPRESENTATION,
+ err = err | cbor_encode_text_string(&map, OC_RSRVD_REPRESENTATION,
sizeof(OC_RSRVD_REPRESENTATION) - 1);
- err = err || cbor_encoder_create_map(&map, &repMap, CborIndefiniteLength);
+ err = err | cbor_encoder_create_map(&map, &repMap, CborIndefiniteLength);
// Platform ID
- err = err || AddTextStringToMap(&repMap, OC_RSRVD_PLATFORM_ID,
+ err = err | AddTextStringToMap(&repMap, OC_RSRVD_PLATFORM_ID,
sizeof(OC_RSRVD_PLATFORM_ID) - 1,
payload->info.platformID);
// MFG Name
- err = err || AddTextStringToMap(&repMap, OC_RSRVD_MFG_NAME,
+ err = err | AddTextStringToMap(&repMap, OC_RSRVD_MFG_NAME,
sizeof(OC_RSRVD_MFG_NAME) - 1,
payload->info.manufacturerName);
// MFG Url
- err = err || ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_URL,
+ err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_URL,
sizeof(OC_RSRVD_MFG_URL) - 1,
payload->info.manufacturerUrl);
// Model Num
- err = err || ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MODEL_NUM,
+ err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MODEL_NUM,
sizeof(OC_RSRVD_MODEL_NUM) - 1,
payload->info.modelNumber);
// Date of Mfg
- err = err || ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_DATE,
+ err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_DATE,
sizeof(OC_RSRVD_MFG_DATE) - 1,
payload->info.dateOfManufacture);
// Platform Version
- err = err || ConditionalAddTextStringToMap(&repMap, OC_RSRVD_PLATFORM_VERSION,
+ err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_PLATFORM_VERSION,
sizeof(OC_RSRVD_PLATFORM_VERSION) - 1,
payload->info.platformVersion);
// OS Version
- err = err || ConditionalAddTextStringToMap(&repMap, OC_RSRVD_OS_VERSION,
+ err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_OS_VERSION,
sizeof(OC_RSRVD_OS_VERSION) - 1,
payload->info.operatingSystemVersion);
// Hardware Version
- err = err || ConditionalAddTextStringToMap(&repMap, OC_RSRVD_HARDWARE_VERSION,
+ err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_HARDWARE_VERSION,
sizeof(OC_RSRVD_HARDWARE_VERSION) - 1,
payload->info.hardwareVersion);
// Firmware Version
- err = err || ConditionalAddTextStringToMap(&repMap, OC_RSRVD_FIRMWARE_VERSION,
+ err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_FIRMWARE_VERSION,
sizeof(OC_RSRVD_FIRMWARE_VERSION) - 1,
payload->info.firmwareVersion);
// Support URL
- err = err || ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SUPPORT_URL,
+ err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SUPPORT_URL,
sizeof(OC_RSRVD_SUPPORT_URL) - 1,
payload->info.supportUrl);
// System Time
- err = err || ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SYSTEM_TIME,
+ err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SYSTEM_TIME,
sizeof(OC_RSRVD_SYSTEM_TIME) - 1,
payload->info.systemTime);
- err = err || cbor_encoder_close_container(&map, &repMap);
+ err = err | cbor_encoder_close_container(&map, &repMap);
}
// Close Map
- err = err || cbor_encoder_close_container(&rootArray, &map);
+ err = err | cbor_encoder_close_container(&rootArray, &map);
}
// Close main array
- err = err || cbor_encoder_close_container(&encoder, &rootArray);
-
- if(err)
- {
- OC_LOG_V(ERROR, TAG, "Convert Platform Payload failed with : %d", err);
- return OC_STACK_ERROR;
- }
+ err = err | cbor_encoder_close_container(&encoder, &rootArray);
- *size = encoder.ptr - *outPayload;
- uint8_t* tempPayload = (uint8_t*)OICRealloc(*outPayload, *size);
+ return checkError(err, &encoder, outPayload, size);
+ }
- if(!tempPayload)
+ static int64_t OCConvertArrayItem(CborEncoder* array, const OCRepPayloadValueArray* valArray,
+ size_t index)
+ {
+ int64_t err = 0;
+ switch (valArray->type)
{
- OC_LOG_V(ERROR, TAG, PCF("Payload realloc failed!"));
- OICFree(*outPayload);
- return OC_STACK_ERROR;
+ case OCREP_PROP_NULL:
+ OC_LOG(ERROR, TAG, "ConvertArray Invalid NULL");
+ err = CborUnknownError;
+ break;
+ case OCREP_PROP_INT:
+ err = err | cbor_encode_int(array, valArray->iArray[index]);
+ break;
+ case OCREP_PROP_DOUBLE:
+ err = err | cbor_encode_double(array, valArray->dArray[index]);
+ break;
+ case OCREP_PROP_BOOL:
+ err = err | cbor_encode_boolean(array, valArray->bArray[index]);
+ break;
+ case OCREP_PROP_STRING:
+ if (!valArray->strArray[index])
+ {
+ err = err | cbor_encode_null(array);
+ }
+ else
+ {
+ err = err | cbor_encode_text_string(array, valArray->strArray[index],
+ strlen(valArray->strArray[index]));
+ }
+ break;
+ case OCREP_PROP_OBJECT:
+ if (!valArray->objArray[index])
+ {
+ err = err | cbor_encode_null(array);
+ }
+ else
+ {
+ err = OCConvertSingleRepPayload(array, valArray->objArray[index]);
+ }
+ break;
+ case OCREP_PROP_ARRAY:
+ OC_LOG(ERROR, TAG, "ConvertArray Invalid child array");
+ err = CborUnknownError;
+ break;
}
- *outPayload = tempPayload;
-
- return OC_STACK_OK;
+ return err;
}
-
- static bool OCConvertSingleRepPayload(CborEncoder* parent, const OCRepPayload* payload);
-
- static bool OCConvertArray(CborEncoder* parent, const OCRepPayloadValueArray* valArray)
+ static int64_t OCConvertArray(CborEncoder* parent, const OCRepPayloadValueArray* valArray)
{
CborEncoder array;
- bool err = false;
+ int64_t err = 0;
+
+ err = err | cbor_encoder_create_array(parent, &array, valArray->dimensions[0]);
- err = err || cbor_encoder_create_array(parent, &array, CborIndefiniteLength);
- err = err || cbor_encode_uint(&array, valArray->type);
- for(int i = 0; i < MAX_REP_ARRAY_DEPTH; ++i)
+ for (size_t i = 0; i < valArray->dimensions[0];++i)
{
- err = err || cbor_encode_uint(&array, valArray->dimensions[i]);
- }
+ if (valArray->dimensions[1] != 0)
+ {
+ CborEncoder array2;
+ err = err | cbor_encoder_create_array(&array, &array2, valArray->dimensions[1]);
- size_t dimTotal = calcDimTotal(valArray->dimensions);
+ for (size_t j = 0; j < valArray->dimensions[1]; ++j)
+ {
+ if (valArray->dimensions[2] != 0)
+ {
+ CborEncoder array3;
+ err = err | cbor_encoder_create_array(&array2, &array3,
+ valArray->dimensions[2]);
- for(size_t i = 0; i < dimTotal; ++i)
- {
- switch(valArray->type)
+ for(size_t k = 0; k < valArray->dimensions[2]; ++k)
+ {
+ OCConvertArrayItem(&array3, valArray,
+ j * valArray->dimensions[2] +
+ i * valArray->dimensions[2] * valArray->dimensions[1] +
+ k);
+ }
+ err = err | cbor_encoder_close_container(&array2, &array3);
+ }
+ else
+ {
+ OCConvertArrayItem(&array2, valArray,
+ i * valArray->dimensions[1] + j);
+ }
+ }
+ err = err | cbor_encoder_close_container(&array, &array2);
+ }
+ else
{
- case OCREP_PROP_NULL:
- OC_LOG(ERROR, TAG, PCF("ConvertArray Invalid NULL"));
- err = CborUnknownError;
- break;
- case OCREP_PROP_INT:
- err = err || cbor_encode_int(&array, valArray->iArray[i]);
- break;
- case OCREP_PROP_DOUBLE:
- err = err || cbor_encode_double(&array, valArray->dArray[i]);
- break;
- case OCREP_PROP_BOOL:
- err = err || cbor_encode_boolean(&array, valArray->bArray[i]);
- break;
- case OCREP_PROP_STRING:
- err = err || cbor_encode_text_string(&array, valArray->strArray[i],
- strlen(valArray->strArray[i]));
- break;
- case OCREP_PROP_OBJECT:
- err = OCConvertSingleRepPayload(&array, valArray->objArray[i]);
- break;
- case OCREP_PROP_ARRAY:
- OC_LOG(ERROR, TAG, PCF("ConvertArray Invalid child array"));
- err = CborUnknownError;
- break;
+ OCConvertArrayItem(&array, valArray, i);
}
}
-
- err = err || cbor_encoder_close_container(parent, &array);
+ err = err | cbor_encoder_close_container(parent, &array);
return err;
}
- static bool OCConvertSingleRepPayload(CborEncoder* parent, const OCRepPayload* payload)
+ static int64_t OCConvertSingleRepPayload(CborEncoder* parent, const OCRepPayload* payload)
{
- bool err = false;
+ int64_t err = 0;
CborEncoder map;
- err = err || cbor_encoder_create_map(parent, &map, CborIndefiniteLength);
+ err = err | cbor_encoder_create_map(parent, &map, CborIndefiniteLength);
// Uri
- err = err || ConditionalAddTextStringToMap(&map, OC_RSRVD_HREF,
+ err = err | ConditionalAddTextStringToMap(&map, OC_RSRVD_HREF,
sizeof(OC_RSRVD_HREF) - 1,
payload->uri);
// resource types, interfaces
if(payload->types || payload->interfaces)
{
- OC_LOG_V(INFO, TAG, "Payload has types or interfaces");
- err = err || cbor_encode_text_string(&map,
+ OC_LOG(INFO, TAG, "Payload has types or interfaces");
+ err = err | cbor_encode_text_string(&map,
OC_RSRVD_PROPERTY,
sizeof(OC_RSRVD_PROPERTY) - 1);
CborEncoder propMap;
- err = err || cbor_encoder_create_map(&map, &propMap, 2);
+ err = err | cbor_encoder_create_map(&map, &propMap, 2);
CborEncoder curArray;
if(payload->types)
{
- err = err || cbor_encode_text_string(&propMap,
+ err = err | cbor_encode_text_string(&propMap,
OC_RSRVD_RESOURCE_TYPE,
sizeof(OC_RSRVD_RESOURCE_TYPE) - 1);
- err = err || cbor_encoder_create_array(&propMap, &curArray, CborIndefiniteLength);
+ err = err | cbor_encoder_create_array(&propMap, &curArray, CborIndefiniteLength);
OCStringLL* val = payload->types;
while(val)
{
- err = err || cbor_encode_text_string(&curArray, val->value, strlen(val->value));
+ err = err | cbor_encode_text_string(&curArray, val->value, strlen(val->value));
val = val->next;
}
- err = err || cbor_encoder_close_container(&propMap, &curArray);
+ err = err | cbor_encoder_close_container(&propMap, &curArray);
}
if(payload->interfaces)
{
- err = err || cbor_encode_text_string(&propMap,
+ err = err | cbor_encode_text_string(&propMap,
OC_RSRVD_INTERFACE,
sizeof(OC_RSRVD_INTERFACE) - 1);
- err = err || cbor_encoder_create_array(&propMap, &curArray, CborIndefiniteLength);
+ err = err | cbor_encoder_create_array(&propMap, &curArray, CborIndefiniteLength);
OCStringLL* val = payload->interfaces;
while(val)
{
- err = err || cbor_encode_text_string(&curArray, val->value, strlen(val->value));
+ err = err | cbor_encode_text_string(&curArray, val->value, strlen(val->value));
val = val->next;
}
- err = err || cbor_encoder_close_container(&propMap, &curArray);
+ err = err | cbor_encoder_close_container(&propMap, &curArray);
}
- err = err || cbor_encoder_close_container(&map, &propMap);
+ err = err | cbor_encoder_close_container(&map, &propMap);
}
// Rep Map
{
CborEncoder repMap;
- err = err || cbor_encode_text_string(&map,
+ err = err | cbor_encode_text_string(&map,
OC_RSRVD_REPRESENTATION,
sizeof(OC_RSRVD_REPRESENTATION) - 1);
- err = err || cbor_encoder_create_map(&map, &repMap, CborIndefiniteLength);
+ err = err | cbor_encoder_create_map(&map, &repMap, CborIndefiniteLength);
OCRepPayloadValue* value = payload->values;
while(value)
{
- err = err || cbor_encode_text_string(&repMap,
+ err = err | cbor_encode_text_string(&repMap,
value->name,
strlen(value->name));
switch(value->type)
{
case OCREP_PROP_NULL:
- err = err || cbor_encode_null(&repMap);
+ err = err | cbor_encode_null(&repMap);
break;
case OCREP_PROP_INT:
- err = err || cbor_encode_int(&repMap,
+ err = err | cbor_encode_int(&repMap,
value->i);
break;
case OCREP_PROP_DOUBLE:
- err = err || cbor_encode_double(&repMap,
+ err = err | cbor_encode_double(&repMap,
value->d);
break;
case OCREP_PROP_BOOL:
- err = err || cbor_encode_boolean(&repMap,
+ err = err | cbor_encode_boolean(&repMap,
value->b);
break;
case OCREP_PROP_STRING:
- err = err || cbor_encode_text_string(&repMap,
+ err = err | cbor_encode_text_string(&repMap,
value->str, strlen(value->str));
break;
case OCREP_PROP_OBJECT:
- err = err || OCConvertSingleRepPayload(&repMap, value->obj);
+ err = err | OCConvertSingleRepPayload(&repMap, value->obj);
break;
case OCREP_PROP_ARRAY:
- err = err || OCConvertArray(&repMap, &value->arr);
+ err = err | OCConvertArray(&repMap, &value->arr);
break;
default:
OC_LOG_V(ERROR, TAG, "Invalid Prop type: %d",
value = value->next;
}
- err = err || cbor_encoder_close_container(&map, &repMap);
+ err = err | cbor_encoder_close_container(&map, &repMap);
}
// Close Map
- err = err || cbor_encoder_close_container(parent, &map);
+ err = err | cbor_encoder_close_container(parent, &map);
return err;
}
- static OCStackResult OCConvertRepPayload(OCRepPayload* payload, uint8_t** outPayload, size_t* size)
+ static int64_t OCConvertRepPayload(OCRepPayload* payload, uint8_t* outPayload, size_t* size)
{
- *outPayload = (uint8_t*)OICCalloc(1, MAX_REQUEST_LENGTH);
- *size = MAX_REQUEST_LENGTH;
-
- if(!*outPayload)
- {
- return OC_STACK_NO_MEMORY;
- }
-
CborEncoder encoder = {0};
- bool err = false;
+ int64_t err = 0;
- cbor_encoder_init(&encoder, *outPayload, *size, 0);
+ cbor_encoder_init(&encoder, outPayload, *size, 0);
CborEncoder rootArray;
- err = err || cbor_encoder_create_array(&encoder, &rootArray, CborIndefiniteLength);
- err = err || cbor_encode_uint(&rootArray, PAYLOAD_TYPE_REPRESENTATION);
+ err = err | cbor_encoder_create_array(&encoder, &rootArray, CborIndefiniteLength);
- while(payload != NULL && !err)
+ while(payload != NULL && (err == 0 || err == CborErrorOutOfMemory))
{
- err = err || OCConvertSingleRepPayload(&rootArray, payload);
+ err = err | OCConvertSingleRepPayload(&rootArray, payload);
payload = payload->next;
}
// Close main array
- err = err || cbor_encoder_close_container(&encoder, &rootArray);
-
- if(err)
- {
- OC_LOG_V(ERROR, TAG, "Convert Rep Payload failed with : %d", err);
- return OC_STACK_ERROR;
- }
-
- *size = encoder.ptr - *outPayload;
- uint8_t* tempPayload = (uint8_t*)OICRealloc(*outPayload, *size);
-
- if(!tempPayload)
- {
- OC_LOG_V(ERROR, TAG, PCF("Payload realloc failed!"));
- OICFree(*outPayload);
- return OC_STACK_ERROR;
- }
-
- *outPayload = tempPayload;
+ err = err | cbor_encoder_close_container(&encoder, &rootArray);
- return OC_STACK_OK;
+ return checkError(err, &encoder, outPayload, size);
}
- static OCStackResult OCConvertPresencePayload(OCPresencePayload* payload,
- uint8_t** outPayload, size_t* size)
+ static int64_t OCConvertPresencePayload(OCPresencePayload* payload,
+ uint8_t* outPayload, size_t* size)
{
- *outPayload = (uint8_t*)OICCalloc(1, MAX_REQUEST_LENGTH);
- *size = MAX_REQUEST_LENGTH;
-
- if(!*outPayload)
- {
- return OC_STACK_NO_MEMORY;
- }
-
CborEncoder encoder = {0};
- bool err = false;
+ int64_t err = 0;
- cbor_encoder_init(&encoder, *outPayload, *size, 0);
+ cbor_encoder_init(&encoder, outPayload, *size, 0);
CborEncoder rootArray;
- err = err || cbor_encoder_create_array(&encoder, &rootArray, 2);
- err = err || cbor_encode_uint(&rootArray, PAYLOAD_TYPE_PRESENCE);
-
+ err = err | cbor_encoder_create_array(&encoder, &rootArray, 1);
CborEncoder map;
- err = err || cbor_encoder_create_map(&rootArray, &map, CborIndefiniteLength);
+ err = err | cbor_encoder_create_map(&rootArray, &map, CborIndefiniteLength);
// Sequence Number
- err = err || cbor_encode_text_string(&map,
+ err = err | cbor_encode_text_string(&map,
OC_RSRVD_NONCE,
sizeof(OC_RSRVD_NONCE) - 1);
- err = err || cbor_encode_uint(&map, payload->sequenceNumber);
+ err = err | cbor_encode_uint(&map, payload->sequenceNumber);
// Max Age
- err = err || cbor_encode_text_string(&map,
+ err = err | cbor_encode_text_string(&map,
OC_RSRVD_TTL,
sizeof(OC_RSRVD_TTL) - 1);
- err = err || cbor_encode_uint(&map, payload->maxAge);
+ err = err | cbor_encode_uint(&map, payload->maxAge);
// Trigger
const char* triggerStr = convertTriggerEnumToString(payload->trigger);
- err = err || AddTextStringToMap(&map, OC_RSRVD_TRIGGER, sizeof(OC_RSRVD_TRIGGER) - 1,
+ err = err | AddTextStringToMap(&map, OC_RSRVD_TRIGGER, sizeof(OC_RSRVD_TRIGGER) - 1,
triggerStr);
// Resource type name
if(payload->trigger != OC_PRESENCE_TRIGGER_DELETE)
{
- err = err || ConditionalAddTextStringToMap(&map, OC_RSRVD_RESOURCE_TYPE,
+ err = err | ConditionalAddTextStringToMap(&map, OC_RSRVD_RESOURCE_TYPE,
sizeof(OC_RSRVD_RESOURCE_TYPE) - 1, payload->resourceType);
}
// Close Map
- err = err || cbor_encoder_close_container(&rootArray, &map);
- err = err || cbor_encoder_close_container(&encoder, &rootArray);
-
- if(err)
- {
- OC_LOG_V(ERROR, TAG, "Convert Presence Payload failed with : %d", err);
- return OC_STACK_ERROR;
- }
-
- *size = encoder.ptr - *outPayload;
- uint8_t* tempPayload = (uint8_t*)OICRealloc(*outPayload, *size);
-
- if(!tempPayload)
- {
- OC_LOG_V(ERROR, TAG, PCF("Payload realloc failed!"));
- OICFree(*outPayload);
- return OC_STACK_ERROR;
- }
-
- *outPayload = tempPayload;
+ err = err | cbor_encoder_close_container(&rootArray, &map);
+ err = err | cbor_encoder_close_container(&encoder, &rootArray);
- return OC_STACK_OK;
+ return checkError(err, &encoder, outPayload, size);
}
- bool AddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
+ static int64_t AddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
const char* value)
{
- return cbor_encode_text_string(map, key, keylen) ||
+ return cbor_encode_text_string(map, key, keylen) |
cbor_encode_text_string(map, value, strlen(value));
}
- bool ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
+ static int64_t ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
const char* value)
{
- return value ? AddTextStringToMap(map, key, keylen, value) : false;
+ return value ? AddTextStringToMap(map, key, keylen, value) : 0;
}
#include "ocpayload.h"
#include "cbor.h"
- #define TAG PCF("OCPayloadParse")
+ #define TAG "OCPayloadParse"
static OCStackResult OCParseDiscoveryPayload(OCPayload** outPayload, CborValue* arrayVal);
static OCStackResult OCParseDevicePayload(OCPayload** outPayload, CborValue* arrayVal);
static OCStackResult OCParsePresencePayload(OCPayload** outPayload, CborValue* arrayVal);
static OCStackResult OCParseSecurityPayload(OCPayload** outPayload, CborValue* arrayVal);
- OCStackResult OCParsePayload(OCPayload** outPayload, const uint8_t* payload, size_t payloadSize)
+ OCStackResult OCParsePayload(OCPayload** outPayload, OCPayloadType payloadType,
+ const uint8_t* payload, size_t payloadSize)
{
CborParser parser;
CborValue rootValue;
bool err = false;
- OC_LOG_V(INFO, TAG, "CBOR Parsing size: %d", payloadSize, payload);
+ OC_LOG_V(INFO, TAG, "CBOR Parsing size: %d", payloadSize);
if((err = cbor_parser_init(payload, payloadSize, 0, &parser, &rootValue)) != false)
{
OC_LOG_V(ERROR, TAG, "CBOR Parser init failed: %d", err);
// enter the array
err = err || cbor_value_enter_container(&rootValue, &arrayValue);
- int payloadType = 0;
- err = err || cbor_value_get_int(&arrayValue, &payloadType);
- err = err || cbor_value_advance_fixed(&arrayValue);
-
- if(err)
+ if(err || arrayValue.type != CborMapType)
{
OC_LOG_V(ERROR, TAG, "CBOR payload parse failed :%d", err);
return OC_STACK_MALFORMED_RESPONSE;
case PAYLOAD_TYPE_SECURITY:
result = OCParseSecurityPayload(outPayload, &arrayValue);
break;
+#ifdef WITH_RD
+ case PAYLOAD_TYPE_RD:
+ result = OCRDCborToPayload(&arrayValue, outPayload);
+ break;
+#endif
default:
OC_LOG_V(ERROR, TAG, "ParsePayload Type default: %d", payloadType);
result = OC_STACK_ERROR;
static OCStackResult OCParseSecurityPayload(OCPayload** outPayload, CborValue* arrayVal)
{
+ if (!outPayload)
+ {
+ return OC_STACK_INVALID_PARAM;
+ }
+
bool err = false;
char * securityData = NULL;
}
else
{
- OC_LOG_V(ERROR, TAG, PCF("Cbor main value not a map"));
+ OC_LOG(ERROR, TAG, "Cbor main value not a map");
return OC_STACK_MALFORMED_RESPONSE;
}
if(err)
{
- OC_LOG_V(ERROR, TAG, "Cbor in error condition");
+ OC_LOG(ERROR, TAG, "Cbor in error condition");
OICFree(securityData);
return OC_STACK_MALFORMED_RESPONSE;
}
static OCStackResult OCParseDiscoveryPayload(OCPayload** outPayload, CborValue* arrayVal)
{
+ if (!outPayload)
+ {
+ return OC_STACK_INVALID_PARAM;
+ }
+
bool err = false;
OCDiscoveryPayload* out = OCDiscoveryPayloadCreate();
OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
if(!resource)
{
- OC_LOG_V(ERROR, TAG, "Memory allocation failed");
+ OC_LOG(ERROR, TAG, "Memory allocation failed");
OCDiscoveryPayloadDestroy(out);
return OC_STACK_NO_MEMORY;
}
llPtr = resource->types;
if(!llPtr)
{
- OC_LOG(ERROR, TAG, PCF("Memory allocation failed"));
+ OC_LOG(ERROR, TAG, "Memory allocation failed");
OICFree(resource->uri);
OICFree(resource->sid);
OICFree(resource);
llPtr = llPtr->next;
if(!llPtr)
{
- OC_LOG(ERROR, TAG, PCF("Memory allocation failed"));
+ OC_LOG(ERROR, TAG, "Memory allocation failed");
OICFree(resource->uri);
OICFree(resource->sid);
OCFreeOCStringLL(resource->types);
}
else
{
- OC_LOG(ERROR, TAG, PCF("Unknown state in resource type copying"));
+ OC_LOG(ERROR, TAG, "Unknown state in resource type copying");
OICFree(resource->uri);
OICFree(resource->sid);
OCFreeOCStringLL(resource->types);
llPtr = resource->interfaces;
if(!llPtr)
{
- OC_LOG_V(ERROR, TAG, "Memory allocation failed");
+ OC_LOG(ERROR, TAG, "Memory allocation failed");
OICFree(resource->uri);
OICFree(resource->sid);
OCFreeOCStringLL(resource->types);
llPtr = llPtr->next;
if(!llPtr)
{
- OC_LOG_V(ERROR, TAG, "Memory allocation failed");
+ OC_LOG(ERROR, TAG, "Memory allocation failed");
OICFree(resource->uri);
OICFree(resource->sid);
OCFreeOCStringLL(resource->types);
}
else
{
- OC_LOG(ERROR, TAG, PCF("Unknown state in resource interfaces copying"));
+ OC_LOG(ERROR, TAG, "Unknown state in resource interfaces copying");
OICFree(resource->uri);
OICFree(resource->sid);
OCFreeOCStringLL(resource->types);
static OCStackResult OCParseDevicePayload(OCPayload** outPayload, CborValue* arrayVal)
{
+ if (!outPayload)
+ {
+ return OC_STACK_INVALID_PARAM;
+ }
+
bool err = false;
if(cbor_value_is_map(arrayVal))
}
else
{
- OC_LOG(ERROR, TAG, PCF("Root device node was not a map"));
+ OC_LOG(ERROR, TAG, "Root device node was not a map");
return OC_STACK_MALFORMED_RESPONSE;
}
static OCStackResult OCParsePlatformPayload(OCPayload** outPayload, CborValue* arrayVal)
{
+ if (!outPayload)
+ {
+ return OC_STACK_INVALID_PARAM;
+ }
+
bool err = false;
if(cbor_value_is_map(arrayVal))
OICFree(info.platformVersion);
OICFree(info.supportUrl);
OICFree(info.systemTime);
- OC_LOG(ERROR, TAG, PCF("CBOR error In ParsePlatformPayload"));
+ OC_LOG(ERROR, TAG, "CBOR error In ParsePlatformPayload");
return OC_STACK_MALFORMED_RESPONSE;
}
}
else
{
- OC_LOG(ERROR, TAG, PCF("Root device node was not a map"));
+ OC_LOG(ERROR, TAG, "Root device node was not a map");
return OC_STACK_MALFORMED_RESPONSE;
}
}
- static bool OCParseArray(OCRepPayload* out, const char* name, CborValue* container)
+ static OCRepPayloadPropType DecodeCborType(CborType type)
{
+ switch (type)
+ {
+ case CborNullType:
+ return OCREP_PROP_NULL;
+ case CborIntegerType:
+ return OCREP_PROP_INT;
+ case CborDoubleType:
+ return OCREP_PROP_DOUBLE;
+ case CborBooleanType:
+ return OCREP_PROP_BOOL;
+ case CborTextStringType:
+ return OCREP_PROP_STRING;
+ case CborMapType:
+ return OCREP_PROP_OBJECT;
+ case CborArrayType:
+ return OCREP_PROP_ARRAY;
+ default:
+ return OCREP_PROP_NULL;
+ }
+ }
+ static bool OCParseArrayFindDimensionsAndType(const CborValue* parent, size_t dimensions[MAX_REP_ARRAY_DEPTH],
+ OCRepPayloadPropType* type)
+ {
+ bool err = false;
CborValue insideArray;
+ *type = OCREP_PROP_NULL;
+ dimensions[0] = dimensions[1] = dimensions[2] = 0;
+
+ err = err || cbor_value_enter_container(parent, &insideArray);
+
+ while (cbor_value_is_valid(&insideArray))
+ {
+ OCRepPayloadPropType tempType = DecodeCborType(cbor_value_get_type(&insideArray));
+
+ if (tempType == OCREP_PROP_ARRAY)
+ {
+ size_t subdim[MAX_REP_ARRAY_DEPTH];
+ tempType = OCREP_PROP_NULL;
+ err = err || OCParseArrayFindDimensionsAndType(&insideArray, subdim, &tempType);
+
+ if (subdim[2] != 0)
+ {
+ OC_LOG(ERROR, TAG, "Parse array helper, sub-array too deep");
+ }
+
+ dimensions[1] = dimensions[1] >= subdim[0] ? dimensions[1] : subdim[0];
+ dimensions[2] = dimensions[2] >= subdim[1] ? dimensions[2] : subdim[1];
+
+ if (*type != OCREP_PROP_NULL && tempType != OCREP_PROP_NULL
+ && *type != tempType)
+ {
+ OC_LOG(ERROR, TAG, "Array parse failed, mixed arrays not allowed (subtype)");
+ return true;
+ }
+ else if (*type == OCREP_PROP_NULL)
+ {
+ // We don't know the type of this array yet, so the assignment is OK
+ *type = tempType;
+ }
+ }
+ else if (*type == OCREP_PROP_NULL)
+ {
+ // We don't know the type of this array yet, so the assignment is OK
+ *type = tempType;
+ }
+ // tempType is allowed to be NULL, since it might now know the answer yet
+ else if (tempType != OCREP_PROP_NULL && *type != tempType)
+ {
+ // this is an invalid situation!
+ OC_LOG(ERROR, TAG, "Array parse failed, mixed arrays not allowed");
+ return true;
+ }
+
+ ++dimensions[0];
+ cbor_value_advance(&insideArray);
+ }
+
+ return err;
+ }
+
+ static size_t getAllocSize(OCRepPayloadPropType type)
+ {
+ switch (type)
+ {
+ case OCREP_PROP_INT:
+ return sizeof (int64_t);
+ case OCREP_PROP_DOUBLE:
+ return sizeof (double);
+ case OCREP_PROP_BOOL:
+ return sizeof (bool);
+ case OCREP_PROP_STRING:
+ return sizeof (char*);
+ case OCREP_PROP_OBJECT:
+ return sizeof (OCRepPayload*);
+ default:
+ return 0;
+ }
+ }
+
+ static size_t arrayStep(size_t dimensions[MAX_REP_ARRAY_DEPTH], size_t elementNum)
+ {
+ return
+ (dimensions[1] == 0 ? 1 : dimensions[1]) *
+ (dimensions[2] == 0 ? 1 : dimensions[2]) *
+ elementNum;
+ }
+
+ static bool OCParseArrayFillArray(const CborValue* parent, size_t dimensions[MAX_REP_ARRAY_DEPTH],
+ OCRepPayloadPropType type, void* targetArray)
+ {
bool err = false;
- uint64_t tempInt = 0;
+ CborValue insideArray;
+
+ err = err || cbor_value_enter_container(parent, &insideArray);
+
+ size_t i = 0;
+ char* tempStr = NULL;
+ size_t tempLen = 0;
+ OCRepPayload* tempPl = NULL;
+
+ size_t newdim[MAX_REP_ARRAY_DEPTH];
+ newdim[0] = dimensions[1];
+ newdim[1] = dimensions[2];
+ newdim[2] = 0;
+
+ while (!err && i < dimensions[0] && cbor_value_is_valid(&insideArray))
+ {
+ if (cbor_value_get_type(&insideArray) != CborNullType)
+ {
+ switch (type)
+ {
+ case OCREP_PROP_INT:
+ if (dimensions[1] == 0)
+ {
+ err = err || cbor_value_get_int64(&insideArray,
+ &(((int64_t*)targetArray)[i]));
+ }
+ else
+ {
+ err = err || OCParseArrayFillArray(&insideArray, newdim,
+ type,
+ &(((int64_t*)targetArray)[arrayStep(dimensions, i)])
+ );
+ }
+ break;
+ case OCREP_PROP_DOUBLE:
+ if (dimensions[1] == 0)
+ {
+ err = err || cbor_value_get_double(&insideArray,
+ &(((double*)targetArray)[i]));
+ }
+ else
+ {
+ err = err || OCParseArrayFillArray(&insideArray, newdim,
+ type,
+ &(((double*)targetArray)[arrayStep(dimensions, i)])
+ );
+ }
+ break;
+ case OCREP_PROP_BOOL:
+ if (dimensions[1] == 0)
+ {
+ err = err || cbor_value_get_boolean(&insideArray,
+ &(((bool*)targetArray)[i]));
+ }
+ else
+ {
+ err = err || OCParseArrayFillArray(&insideArray, newdim,
+ type,
+ &(((bool*)targetArray)[arrayStep(dimensions, i)])
+ );
+ }
+ break;
+ case OCREP_PROP_STRING:
+ if (dimensions[1] == 0)
+ {
+ err = err || cbor_value_dup_text_string(&insideArray,
+ &tempStr, &tempLen, NULL);
+ ((char**)targetArray)[i] = tempStr;
+ tempStr = NULL;
+ }
+ else
+ {
+ err = err || OCParseArrayFillArray(&insideArray, newdim,
+ type,
+ &(((char**)targetArray)[arrayStep(dimensions, i)])
+ );
+ }
+ break;
+ case OCREP_PROP_OBJECT:
+ if (dimensions[1] == 0)
+ {
+ err = err || OCParseSingleRepPayload(&tempPl, &insideArray);
+ ((OCRepPayload**)targetArray)[i] = tempPl;
+ tempPl = NULL;
+ }
+ else
+ {
+ err = err || OCParseArrayFillArray(&insideArray, newdim,
+ type,
+ &(((OCRepPayload**)targetArray)[arrayStep(dimensions, i)])
+ );
+ }
+ break;
+ default:
+ OC_LOG(ERROR, TAG, "Invalid Array type in Parse Array");
+ err = true;
+ break;
+ }
+ }
+ ++i;
+ err = err || cbor_value_advance(&insideArray);
+ }
+
+ return err;
+ }
+
+ static bool OCParseArray(OCRepPayload* out, const char* name, CborValue* container)
+ {
OCRepPayloadPropType type;
size_t dimensions[MAX_REP_ARRAY_DEPTH];
- err = err || cbor_value_enter_container(container, &insideArray);
+ bool err = OCParseArrayFindDimensionsAndType(container, dimensions, &type);
- err = err || cbor_value_get_uint64(&insideArray, &tempInt);
- err = err || cbor_value_advance_fixed(&insideArray);
- type = (OCRepPayloadPropType)tempInt;
+ if (err)
+ {
+ OC_LOG(ERROR, TAG, "Array details weren't clear");
+ return err;
+ }
- for(int i = 0; i < MAX_REP_ARRAY_DEPTH; ++ i)
+ if (type == OCREP_PROP_NULL)
{
- err = err || cbor_value_get_uint64(&insideArray, &tempInt);
- err = err || cbor_value_advance_fixed(&insideArray);
- dimensions[i] = tempInt;
+ err = err || OCRepPayloadSetNull(out, name);
+ err = err || cbor_value_advance(container);
+ return err;
}
size_t dimTotal = calcDimTotal(dimensions);
+ size_t allocSize = getAllocSize(type);
+ void* arr = OICCalloc(dimTotal, allocSize);
- void* arr = NULL;
- char* tempStr;
- size_t len;
- OCRepPayload* pl;
- switch(type)
+ if (!arr)
+ {
+ OC_LOG(ERROR, TAG, "Array Parse allocation failed");
+ return true;
+ }
+
+ err = err || OCParseArrayFillArray(container, dimensions, type, arr);
+
+ switch (type)
{
case OCREP_PROP_INT:
- arr = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
- if (arr)
- {
- for(size_t i = 0; i < dimTotal && !err; ++i)
- {
- err = err || cbor_value_get_int64(&insideArray, &(((int64_t*)arr)[i]));
- err = err || cbor_value_advance_fixed(&insideArray);
- }
- if(err || !OCRepPayloadSetIntArrayAsOwner(out, name, (int64_t*)arr, dimensions))
- {
- OICFree(arr);
- err = true;
- }
- }
- else
+ if (err || !OCRepPayloadSetIntArrayAsOwner(out, name, (int64_t*)arr, dimensions))
{
+ OICFree(arr);
err = true;
}
break;
case OCREP_PROP_DOUBLE:
- arr = (double*)OICMalloc(dimTotal * sizeof(double));
- if(arr)
- {
- for(size_t i = 0; i < dimTotal && !err; ++i)
- {
- err = err || cbor_value_get_double(&insideArray, &(((double*)arr)[i]));
- err = err || cbor_value_advance_fixed(&insideArray);
- }
- if(err || !OCRepPayloadSetDoubleArrayAsOwner(out, name, (double*)arr, dimensions))
- {
- OICFree(arr);
- err = true;
- }
- }
- else
+ if (err || !OCRepPayloadSetDoubleArrayAsOwner(out, name, (double*)arr, dimensions))
{
+ OICFree(arr);
err = true;
}
break;
case OCREP_PROP_BOOL:
- arr = (bool*)OICMalloc(dimTotal * sizeof(bool));
- if(arr)
- {
- for(size_t i = 0; i < dimTotal && !err; ++i)
- {
- err = err || cbor_value_get_boolean(&insideArray, &(((bool*)arr)[i]));
- err = err || cbor_value_advance_fixed(&insideArray);
- }
- if(err && !OCRepPayloadSetBoolArrayAsOwner(out, name, (bool*)arr, dimensions))
- {
- OICFree(arr);
- err = true;
- }
- }
- else
+ if (err || !OCRepPayloadSetBoolArrayAsOwner(out, name, (bool*)arr, dimensions))
{
+ OICFree(arr);
err = true;
}
break;
case OCREP_PROP_STRING:
- arr = (char**)OICMalloc(dimTotal * sizeof(char*));
- if(arr)
+ if (err || !OCRepPayloadSetStringArrayAsOwner(out, name, (char**)arr, dimensions))
{
- for(size_t i = 0; i < dimTotal && !err; ++i)
- {
- err = err || cbor_value_dup_text_string(&insideArray, &tempStr,
- &len, NULL);
- err = err || cbor_value_advance(&insideArray);
- ((char**)arr)[i] = tempStr;
- }
- if(err || !OCRepPayloadSetStringArrayAsOwner(out, name, (char**)arr, dimensions))
+ for(size_t i = 0; i < dimTotal; ++i)
{
- OICFree(arr);
- err = true;
+ OICFree(((char**)arr)[i]);
}
- }
- else
- {
+ OICFree(arr);
err = true;
}
break;
case OCREP_PROP_OBJECT:
- arr = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
- if(arr)
+ if (err || !OCRepPayloadSetPropObjectArrayAsOwner(out, name, (OCRepPayload**)arr, dimensions))
{
- for(size_t i = 0; i < dimTotal && !err; ++i)
- {
- pl = NULL;
- err = err || OCParseSingleRepPayload(&pl, &insideArray);
- err = err || cbor_value_advance(&insideArray);
- ((OCRepPayload**)arr)[i] = pl;
- }
- if(err || !OCRepPayloadSetPropObjectArrayAsOwner(out, name,
- (OCRepPayload**)arr, dimensions))
+ for(size_t i = 0; i < dimTotal; ++i)
{
- OICFree(arr);
- err = true;
+ OCRepPayloadDestroy(((OCRepPayload**)arr)[i]);
}
- }
- else
- {
+ OICFree(arr);
err = true;
}
break;
static bool OCParseSingleRepPayload(OCRepPayload** outPayload, CborValue* repParent)
{
+ if (!outPayload)
+ {
+ return false;
+ }
+
*outPayload = OCRepPayloadCreate();
OCRepPayload* curPayload = *outPayload;
bool err = false;
err = err || cbor_value_leave_container(&insidePropArray, &ifArray);
}
}
+
err = err || cbor_value_map_find_value(repParent, OC_RSRVD_REPRESENTATION, &curVal);
if(cbor_value_is_map(&curVal))
{
while(!err && cbor_value_is_valid(&repMap))
{
char* name;
- err = err || cbor_value_dup_text_string(&repMap, &name, &len, NULL);
+ err = err || cbor_value_dup_text_string(&repMap, &name, &len, NULL);
- err = err || cbor_value_advance(&repMap);
+ err = err || cbor_value_advance(&repMap);
int64_t intval = 0;
bool boolval = false;
}
static OCStackResult OCParseRepPayload(OCPayload** outPayload, CborValue* arrayVal)
{
+ if (!outPayload)
+ {
+ return OC_STACK_INVALID_PARAM;
+ }
+
bool err = false;
OCRepPayload* rootPayload = NULL;
if(err)
{
OCRepPayloadDestroy(rootPayload);
- OC_LOG_V(ERROR, TAG, PCF("CBOR error in ParseRepPayload"));
+ OC_LOG(ERROR, TAG, "CBOR error in ParseRepPayload");
return OC_STACK_MALFORMED_RESPONSE;
}
}
static OCStackResult OCParsePresencePayload(OCPayload** outPayload, CborValue* arrayVal)
{
+ if (!outPayload)
+ {
+ return OC_STACK_INVALID_PARAM;
+ }
+
bool err = false;
if(cbor_value_is_map(arrayVal))
{
if(err)
{
OCPayloadDestroy(*outPayload);
- OC_LOG_V(ERROR, TAG, PCF("CBOR error Parse Presence Payload"));
+ OC_LOG(ERROR, TAG, "CBOR error Parse Presence Payload");
return OC_STACK_MALFORMED_RESPONSE;
}
}
else
{
- OC_LOG(ERROR, TAG, PCF("Root presence node was not a map"));
+ OC_LOG(ERROR, TAG, "Root presence node was not a map");
return OC_STACK_MALFORMED_RESPONSE;
}
}
// For POSIX.1-2001 base specification,
// Refer http://pubs.opengroup.org/onlinepubs/009695399/
#define _POSIX_C_SOURCE 200112L
- #include "ocresource.h"
#include <string.h>
+ #include "ocresource.h"
#include "ocresourcehandler.h"
#include "ocobserve.h"
#include "occollection.h"
#include "logger.h"
#include "cJSON.h"
#include "ocpayload.h"
-
+ #include "secureresourcemanager.h"
#include "cacommon.h"
#include "cainterface.h"
+
+#ifdef WITH_RD
+#include "rd_server.h"
++#endif
++
+ #ifdef ROUTING_GATEWAY
+ #include "routingmanager.h"
#endif
/// Module Name
- #define TAG PCF("ocresource")
+ #define TAG "ocresource"
#define VERIFY_SUCCESS(op, successCode) { if (op != successCode) \
{OC_LOG_V(FATAL, TAG, "%s failed!!", #op); goto exit;} }
#define VERIFY_NON_NULL(arg, logLevel, retVal) { if (!(arg)) { OC_LOG((logLevel), \
- TAG, PCF(#arg " is NULL")); return (retVal); } }
+ TAG, #arg " is NULL"); return (retVal); } }
extern OCResource *headResource;
static OCPlatformInfo savedPlatformInfo = {0};
{
if (numKeyValuePairsParsed >= 2)
{
- OC_LOG(ERROR, TAG, PCF("More than 2 queries params in URI."));
+ OC_LOG(ERROR, TAG, "More than 2 queries params in URI.");
return OC_STACK_INVALID_QUERY;
}
{
return OC_RESOURCE_TYPES_URI;
}
+ #ifdef ROUTING_GATEWAY
+ else if (0 == strcmp(uriInRequest, OC_RSRVD_GATEWAY_URI))
+ {
+ return OC_GATEWAY_URI;
+ }
+ #endif
#ifdef WITH_PRESENCE
else if (strcmp(uriInRequest, OC_RSRVD_PRESENCE_URI) == 0)
{
if (uri == OC_PRESENCE)
{
//Nothing needs to be done, except for pass a OC_PRESENCE query through as OC_STACK_OK.
- OC_LOG(INFO, TAG, PCF("OC_PRESENCE Request for virtual resource."));
+ OC_LOG(INFO, TAG, "OC_PRESENCE Request for virtual resource.");
return OC_STACK_OK;
}
#endif
}
else
{
- OCResource *resourcePtr = NULL;
- resourcePtr = FindResourceByUri((const char*)request->resourceUrl);
+ OCResource *resourcePtr = FindResourceByUri((const char*)request->resourceUrl);
*resource = resourcePtr;
if (!resourcePtr)
{
resourceTypePtr = resourceTypePtr->next;
}
- OC_LOG_V(INFO, TAG, PCF("%s does not contain rt=%s."), resource->uri, resourceTypeFilter);
+ OC_LOG_V(INFO, TAG, "%s does not contain rt=%s.", resource->uri, resourceTypeFilter);
return false;
}
interfacePtr = interfacePtr->next;
}
- OC_LOG_V(INFO, TAG, PCF("%s does not contain if=%s."), resource->uri, interfaceFilter);
+ OC_LOG_V(INFO, TAG, "%s does not contain if=%s.", resource->uri, interfaceFilter);
return false;
}
{
if (!resource)
{
- OC_LOG(ERROR, TAG, PCF("Invalid resource"));
+ OC_LOG(ERROR, TAG, "Invalid resource");
return false;
}
if (!((interfaceFilter && *interfaceFilter ) ||
(resourceTypeFilter && *resourceTypeFilter)))
{
- OC_LOG_V(INFO, TAG, PCF("%s no query string for EXPLICIT_DISCOVERABLE \
- resource"), resource->uri);
+ OC_LOG_V(INFO, TAG, "%s no query string for EXPLICIT_DISCOVERABLE \
+ resource", resource->uri);
return false;
}
}
else if ( !(resource->resourceProperties & OC_ACTIVE) ||
!(resource->resourceProperties & OC_DISCOVERABLE))
{
- OC_LOG_V(INFO, TAG, PCF("%s not ACTIVE or DISCOVERABLE"), resource->uri);
+ OC_LOG_V(INFO, TAG, "%s not ACTIVE or DISCOVERABLE", resource->uri);
return false;
}
return OCDoResponse(&response);
}
+#ifdef WITH_RD
+static OCStackResult checkResourceExistsAtRD(const char *interfaceType, const char *resourceType, OCRepPayload **repPayload)
+{
+ char *uri = NULL;
+ char *rt = NULL;
+ char *itf = NULL;
+
+ if (OCRDCheckPublishedResource(interfaceType, resourceType, &uri, &rt, &itf) == OC_STACK_OK)
+ {
+ if (!uri || !rt || !itf)
+ {
+ OC_LOG_V(ERROR, TAG, "Failed allocating memory.");
+ // if any of the parameter has memory allocated free each one of them.
+ OICFree(uri);
+ OICFree(rt);
+ OICFree(itf);
+ return OC_STACK_NO_MEMORY;
+ }
+
+ OCRepPayload *rdResource = OICCalloc(1, sizeof(OCRepPayload));
+ if (!rdResource)
+ {
+ OC_LOG_V(ERROR, TAG, "Failed allocating memory.");
+ OICFree(uri);
+ OICFree(rt);
+ OICFree(itf);
+ return OC_STACK_NO_MEMORY;
+ }
+
+ rdResource->uri = uri;
+
+ rdResource->types = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
+ if(!rdResource->types)
+ {
+ OC_LOG_V(ERROR, TAG, "Failed allocating memory.");
+ OICFree(uri);
+ OICFree(rt);
+ OICFree(itf);
+ OICFree(rdResource);
+ return OC_STACK_NO_MEMORY;
+ }
+ rdResource->types->value = rt;
+
+ rdResource->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
+ if(!rdResource->interfaces)
+ {
+ OC_LOG_V(ERROR, TAG, "Failed allocating memory.");
+ OICFree(uri);
+ OICFree(rt);
+ OICFree(itf);
+ OICFree(rdResource);
+ return OC_STACK_NO_MEMORY;
+ }
+ rdResource->interfaces->value = itf;
+
+ *repPayload = rdResource;
+
+ return OC_STACK_OK;
+ }
+ else
+ {
+ OC_LOG_V(ERROR, TAG, "The resource type or interface type doe not exist \
+ on the resource directory");
+ }
+ return OC_STACK_ERROR;
+}
+#endif
+
static OCStackResult HandleVirtualResource (OCServerRequest *request, OCResource* resource)
{
if (!request || !resource)
bool bMulticast = false; // Was the discovery request a multicast request?
OCPayload* payload = NULL;
- OC_LOG(INFO, TAG, PCF("Entering HandleVirtualResource"));
+ OC_LOG(INFO, TAG, "Entering HandleVirtualResource");
OCVirtualResources virtualUriInRequest = GetTypeOfVirtualURI (request->resourceUrl);
{
for(;resource && discoveryResult == OC_STACK_OK; resource = resource->next)
{
- if(includeThisResourceInResponse(resource, filterOne, filterTwo))
+ bool foundResourceAtRD = false;
+#ifdef WITH_RD
+ if (strcmp(resource->uri, OC_RSRVD_RD_URI) == 0)
+ {
+ OCRepPayload *repPayload = NULL;
+ discoveryResult = checkResourceExistsAtRD(filterOne, filterTwo, &repPayload);
+ if (discoveryResult != OC_STACK_OK)
+ {
+ break;
+ }
+ discoveryResult = BuildVirtualResourceResponse((OCResource *)repPayload,
+ (OCDiscoveryPayload*)payload,
+ &request->devAddr);
+ foundResourceAtRD = true;
+ }
+#endif
+ if(!foundResourceAtRD && includeThisResourceInResponse(resource, filterOne, filterTwo))
{
discoveryResult = BuildVirtualResourceResponse(resource,
(OCDiscoveryPayload*)payload,
}
else if (virtualUriInRequest == OC_DEVICE_URI)
{
- payload = (OCPayload*)OCDevicePayloadCreate(OC_RSRVD_DEVICE_URI,
- OCGetServerInstanceID(), savedDeviceInfo.deviceName,
- OC_SPEC_VERSION, OC_DATA_MODEL_VERSION);
- if (!payload)
+ const OicUuid_t* deviceId = OCGetServerInstanceID();
+ if (!deviceId)
{
- discoveryResult = OC_STACK_NO_MEMORY;
+ discoveryResult = OC_STACK_ERROR;
}
else
{
- discoveryResult = OC_STACK_OK;
+ payload = (OCPayload*) OCDevicePayloadCreate(OC_RSRVD_DEVICE_URI,
+ (const uint8_t*) &deviceId->id, savedDeviceInfo.deviceName,
+ OC_SPEC_VERSION, OC_DATA_MODEL_VERSION);
+ if (!payload)
+ {
+ discoveryResult = OC_STACK_NO_MEMORY;
+ }
+ else
+ {
+ discoveryResult = OC_STACK_OK;
+ }
}
}
else if (virtualUriInRequest == OC_PLATFORM_URI)
discoveryResult = OC_STACK_OK;
}
}
+ #ifdef ROUTING_GATEWAY
+ else if (OC_GATEWAY_URI == virtualUriInRequest)
+ {
+ // Received request for a gateway
+ OC_LOG(INFO, TAG, "Request is for Gateway Virtual Request");
+ discoveryResult = RMHandleGatewayRequest(request, resource);
+
+ }
+ #endif
/**
* Step 2: Send the discovery response
* request is unicast, it should send an error(RESOURCE_NOT_FOUND - 404) response.
*/
- #ifdef WITH_PRESENCE
+ #ifdef WITH_PRESENCE
if ((virtualUriInRequest == OC_PRESENCE) &&
(resource->resourceProperties & OC_ACTIVE))
{
}
else
#endif
+ #ifdef ROUTING_GATEWAY
+ // Gateway uses the RMHandleGatewayRequest to respond to the request.
+ if (OC_GATEWAY != virtualUriInRequest)
+ #endif
{
if(discoveryResult == OC_STACK_OK)
{
else
{
// Ignoring the discovery request as per RFC 7252, Section #8.2
- OC_LOG_V(INFO, TAG, "Silently ignoring the request since device does not have \
+ OC_LOG(INFO, TAG, "Silently ignoring the request since device does not have \
any useful data to send");
}
}
OCEntityHandlerResult ehResult = OC_EH_ERROR;
OCEntityHandlerRequest ehRequest = {0};
- OC_LOG(INFO, TAG, PCF("Entering HandleResourceWithDefaultDeviceEntityHandler"));
+ OC_LOG(INFO, TAG, "Entering HandleResourceWithDefaultDeviceEntityHandler");
result = FormOCEntityHandlerRequest(&ehRequest,
(OCRequestHandle) request,
request->method,
&request->devAddr,
(OCResourceHandle) NULL, request->query,
+ PAYLOAD_TYPE_REPRESENTATION,
request->payload,
request->payloadSize,
request->numRcvdVendorSpecificHeaderOptions,
(char*) request->resourceUrl, defaultDeviceHandlerCallbackParameter);
if(ehResult == OC_EH_SLOW)
{
- OC_LOG(INFO, TAG, PCF("This is a slow resource"));
+ OC_LOG(INFO, TAG, "This is a slow resource");
request->slowFlag = 1;
}
else if(ehResult == OC_EH_ERROR)
OCEntityHandlerRequest ehRequest = {0};
- OC_LOG(INFO, TAG, PCF("Entering HandleResourceWithEntityHandler"));
+ OC_LOG(INFO, TAG, "Entering HandleResourceWithEntityHandler");
+ OCPayloadType type = PAYLOAD_TYPE_REPRESENTATION;
+ // check the security resource
+ if (request && request->resourceUrl && SRMIsSecurityResourceURI(request->resourceUrl))
+ {
+ type = PAYLOAD_TYPE_SECURITY;
+ }
result = FormOCEntityHandlerRequest(&ehRequest,
(OCRequestHandle)request,
request->method,
&request->devAddr,
(OCResourceHandle)resource,
request->query,
+ type,
request->payload,
request->payloadSize,
request->numRcvdVendorSpecificHeaderOptions,
if(ehRequest.obsInfo.action == OC_OBSERVE_NO_OPTION)
{
- OC_LOG(INFO, TAG, PCF("No observation requested"));
+ OC_LOG(INFO, TAG, "No observation requested");
ehFlag = OC_REQUEST_FLAG;
}
else if(ehRequest.obsInfo.action == OC_OBSERVE_REGISTER && !collectionResource)
{
- OC_LOG(INFO, TAG, PCF("Observation registration requested"));
+ OC_LOG(INFO, TAG, "Observation registration requested");
result = GenerateObserverId(&ehRequest.obsInfo.obsId);
VERIFY_SUCCESS(result, OC_STACK_OK);
result = AddObserver ((const char*)(request->resourceUrl),
(const char *)(request->query),
ehRequest.obsInfo.obsId, request->requestToken, request->tokenLength,
- resource, request->qos,
+ resource, request->qos, request->acceptFormat,
&request->devAddr);
if(result == OC_STACK_OK)
{
- OC_LOG(INFO, TAG, PCF("Added observer successfully"));
+ OC_LOG(INFO, TAG, "Added observer successfully");
request->observeResult = OC_STACK_OK;
ehFlag = (OCEntityHandlerFlag)(OC_REQUEST_FLAG | OC_OBSERVE_FLAG);
}
// The error in observeResult for the request will be used when responding to this
// request by omitting the observation option/sequence number.
request->observeResult = OC_STACK_ERROR;
- OC_LOG(ERROR, TAG, PCF("Observer Addition failed"));
+ OC_LOG(ERROR, TAG, "Observer Addition failed");
ehFlag = OC_REQUEST_FLAG;
}
else if(ehRequest.obsInfo.action == OC_OBSERVE_DEREGISTER &&
!collectionResource)
{
- OC_LOG(INFO, TAG, PCF("Deregistering observation requested"));
+ OC_LOG(INFO, TAG, "Deregistering observation requested");
resObs = GetObserverUsingToken (request->requestToken, request->tokenLength);
if(result == OC_STACK_OK)
{
- OC_LOG(INFO, TAG, PCF("Removed observer successfully"));
+ OC_LOG(INFO, TAG, "Removed observer successfully");
request->observeResult = OC_STACK_OK;
}
else
{
result = OC_STACK_OK;
request->observeResult = OC_STACK_ERROR;
- OC_LOG(ERROR, TAG, PCF("Observer Removal failed"));
+ OC_LOG(ERROR, TAG, "Observer Removal failed");
}
}
else
ehResult = resource->entityHandler(ehFlag, &ehRequest, resource->entityHandlerCallbackParam);
if(ehResult == OC_EH_SLOW)
{
- OC_LOG(INFO, TAG, PCF("This is a slow resource"));
+ OC_LOG(INFO, TAG, "This is a slow resource");
request->slowFlag = 1;
}
else if(ehResult == OC_EH_ERROR)
&request->devAddr,
(OCResourceHandle)resource,
request->query,
+ PAYLOAD_TYPE_REPRESENTATION,
request->payload,
request->payloadSize,
request->numRcvdVendorSpecificHeaderOptions,
}
case OC_RESOURCE_NOT_COLLECTION_DEFAULT_ENTITYHANDLER:
{
- OC_LOG(INFO, TAG, PCF("OC_RESOURCE_NOT_COLLECTION_DEFAULT_ENTITYHANDLER"));
+ OC_LOG(INFO, TAG, "OC_RESOURCE_NOT_COLLECTION_DEFAULT_ENTITYHANDLER");
return OC_STACK_ERROR;
}
case OC_RESOURCE_NOT_COLLECTION_WITH_ENTITYHANDLER:
}
default:
{
- OC_LOG(INFO, TAG, PCF("Invalid Resource Determination"));
+ OC_LOG(INFO, TAG, "Invalid Resource Determination");
return OC_STACK_ERROR;
}
}
void DeletePlatformInfo()
{
- OC_LOG(INFO, TAG, PCF("Deleting platform info."));
+ OC_LOG(INFO, TAG, "Deleting platform info.");
OICFree(savedPlatformInfo.platformID);
savedPlatformInfo.platformID = NULL;
if (res != OC_STACK_OK)
{
- OC_LOG_V(ERROR, TAG, PCF("Failed to save platform info. errno(%d)"), res);
+ OC_LOG_V(ERROR, TAG, "Failed to save platform info. errno(%d)", res);
}
else
{
- OC_LOG(ERROR, TAG, PCF("Platform info saved."));
+ OC_LOG(INFO, TAG, "Platform info saved.");
}
return res;
void DeleteDeviceInfo()
{
- OC_LOG(INFO, TAG, PCF("Deleting device info."));
+ OC_LOG(INFO, TAG, "Deleting device info.");
OICFree(savedDeviceInfo.deviceName);
savedDeviceInfo.deviceName = NULL;
if(OCGetServerInstanceID() == NULL)
{
- OC_LOG(INFO, TAG, PCF("Device ID generation failed"));
+ OC_LOG(INFO, TAG, "Device ID generation failed");
res = OC_STACK_ERROR;
goto exit;
}
- OC_LOG(INFO, TAG, PCF("Device initialized successfully."));
+ OC_LOG(INFO, TAG, "Device initialized successfully.");
return OC_STACK_OK;
- exit:
- DeleteDeviceInfo();
- return res;
-
+ exit:
+ DeleteDeviceInfo();
+ return res;
}
target_os = env.get('TARGET_OS')
- if target_os not in ['arduino','darwin','ios']:
+ if target_os not in ['arduino','darwin']:
# Build things manager project
SConscript('things-manager/SConscript')
# Build protocol plugin project
# protocol-plugin use 'inotify', this feature isn't support by MAC OSX
- if target_os not in ['darwin', 'ios']:
+ if target_os not in ['darwin', 'ios', 'android']:
SConscript('protocol-plugin/SConscript')
# Build notification manager project
- if target_os not in ['android', 'tizen']:
- SConscript('notification-manager/SConscript')
-
+ SConscript('notification-manager/SConscript')
+
# Build resource-encapsulation project
- if target_os not in ['android', 'tizen']:
+ if target_os not in ['tizen']:
SConscript('resource-encapsulation/SConscript')
- #else:
- # SConscript('notification-manager/SampleApp/arduino/SConscript')
+ # Build resource directory project
+ if env.get('WITH_RD') == '1':
+ SConscript('resource-directory/SConscript')
projects / platform / upstream / iotivity.git / commitdiff