Michal
/
esphome_elektromer_han
mirror of https://github.com/Tomer27cz/xt211.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
esphome_elektromer_han/components/xt211/unused/gxinvoke.c

3149 lines
102 KiB
C
Raw Permalink Blame History

//
// --------------------------------------------------------------------------
// Gurux Ltd
//
//
//
// Filename: $HeadURL$
//
// Version: $Revision$,
// $Date$
// $Author$
//
// Copyright (c) Gurux Ltd
//
//---------------------------------------------------------------------------
//
// DESCRIPTION
//
// This file is a part of Gurux Device Framework.
//
// Gurux Device Framework is Open Source software; you can redistribute it
// and/or modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; version 2 of the License.
// Gurux Device Framework is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// This code is licensed under the GNU General Public License v2.
// Full text may be retrieved at http://www.gnu.org/licenses/gpl-2.0.txt
//---------------------------------------------------------------------------
#include "gxignore.h"
#ifndef DLMS_IGNORE_SERVER
#if defined(_WIN32) || defined(_WIN64) || defined(__linux__)
#include <assert.h>
#endif
#include "gxmem.h"
#if _MSC_VER > 1400
#include <crtdbg.h>
#endif
#include <string.h>
#include "cosem.h"
#include "dlms.h"
#include "gxset.h"
#include "gxinvoke.h"
#include "helpers.h"
#include "objectarray.h"
#include "ciphering.h"
#include "gxget.h"
#include "gxkey.h"
#include "serverevents.h"
#ifndef DLMS_IGNORE_CHARGE
int invoke_Charge(
gxCharge* object,
unsigned char index,
dlmsVARIANT* value)
{
gxChargeTable* ct, * it;
int ret = 0, pos;
//Update unit charge.
if (index == 1)
{
for (pos = 0; pos != object->unitChargePassive.chargeTables.size; ++pos)
{
#ifdef DLMS_IGNORE_MALLOC
ret = arr_getByIndex(&object->unitChargePassive.chargeTables, pos, (void**)&ct, sizeof(gxCharge));
#else
ret = arr_getByIndex(&object->unitChargePassive.chargeTables, pos, (void**)&ct);
#endif //DLMS_IGNORE_MALLOC
if (ret != 0)
{
return ret;
}
ct->chargePerUnit = (short)var_toInteger(value);
}
}
//Activate passive unit charge.
else if (index == 2)
{
object->unitChargeActive.chargePerUnitScaling = object->unitChargePassive.chargePerUnitScaling;
object->unitChargeActive.commodity = object->unitChargePassive.commodity;
for (pos = 0; pos != object->unitChargePassive.chargeTables.size; ++pos)
{
#ifdef DLMS_IGNORE_MALLOC
if ((ret = arr_getByIndex(&object->unitChargePassive.chargeTables, pos, (void**)&ct, sizeof(gxChargeTable))) != 0 ||
(ret = arr_getByIndex(&object->unitChargeActive.chargeTables, object->unitChargeActive.chargeTables.size, (void**)&it, sizeof(gxChargeTable))) != 0)
{
break;
}
++object->unitChargeActive.chargeTables.size;
#else
if ((ret = arr_getByIndex(&object->unitChargePassive.chargeTables, pos, (void**)&ct)) != 0)
{
break;
}
it = (gxChargeTable*)gxmalloc(sizeof(gxChargeTable));
arr_push(&object->unitChargeActive.chargeTables, it);
#endif //DLMS_IGNORE_MALLOC
it->chargePerUnit = ct->chargePerUnit;
it->index = ct->index;
}
}
//Update total amount remaining.
else if (index == 4)
{
object->totalAmountRemaining += var_toInteger(value);
}
else
{
ret = DLMS_ERROR_CODE_INVALID_PARAMETER;
}
return ret;
}
#endif //DLMS_IGNORE_CHARGE
#ifndef DLMS_IGNORE_CREDIT
int invoke_Credit(
gxCredit* object,
unsigned char index,
dlmsVARIANT* value)
{
int ret = 0;
//Update amount.
if (index == 1)
{
object->currentCreditAmount += var_toInteger(value);
}
//Set amount to value.
else if (index == 2)
{
object->currentCreditAmount = var_toInteger(value);
}
else if (index == 3)
{
// The mechanism for selecting the <20>Credit<69> is not in the scope of COSEM and
// shall be specified by the implementer (e.g. button push, meter process, script etc.).
object->status |= 4;
}
else
{
ret = DLMS_ERROR_CODE_INVALID_PARAMETER;
}
return ret;
}
#endif //DLMS_IGNORE_CREDIT
#ifndef DLMS_IGNORE_TOKEN_GATEWAY
int invoke_gxTokenGateway(
gxTokenGateway* object,
unsigned char index,
dlmsVARIANT* value)
{
int ret = 0;
//Update token.
if (index == 1)
{
bb_clear(&object->token);
if (value->vt == DLMS_DATA_TYPE_OCTET_STRING)
{
bb_set(&object->token, value->byteArr->data, value->byteArr->size);
}
}
else
{
ret = DLMS_ERROR_CODE_INVALID_PARAMETER;
}
return ret;
}
#endif //DLMS_IGNORE_TOKEN_GATEWAY
#ifndef DLMS_IGNORE_ASSOCIATION_LOGICAL_NAME
int invoke_AssociationLogicalName(
dlmsServerSettings* settings,
gxValueEventArg* e)
{
int ret = 0;
gxAssociationLogicalName* object = (gxAssociationLogicalName*)e->target;
// Check reply_to_HLS_authentication
if (e->index == 1)
{
#ifndef DLMS_IGNORE_HIGH_GMAC
unsigned char ch;
gxByteBuffer tmp;
#endif //DLMS_IGNORE_HIGH_GMAC
unsigned char tmp2[64];
unsigned char equal;
uint32_t ic = 0;
gxByteBuffer bb;
gxByteBuffer* readSecret;
BYTE_BUFFER_INIT(&bb);
#ifdef DLMS_IGNORE_MALLOC
uint16_t count;
if ((ret = bb_getUInt8(e->parameters.byteArr, &ch)) != 0)
{
return ret;
}
if (ch != DLMS_DATA_TYPE_OCTET_STRING)
{
#ifdef DLMS_DEBUG
svr_notifyTrace("High authentication failed. ", DLMS_ERROR_CODE_INVALID_PARAMETER);
#endif //DLMS_DEBUG
return DLMS_ERROR_CODE_INVALID_PARAMETER;
}
if ((ret = hlp_getObjectCount2(e->parameters.byteArr, &count)) != 0)
{
#ifdef DLMS_DEBUG
svr_notifyTrace("High authentication failed. ", DLMS_ERROR_CODE_INVALID_PARAMETER);
#endif //DLMS_DEBUG
return ret;
}
if (count > bb_available(e->parameters.byteArr))
{
#ifdef DLMS_DEBUG
svr_notifyTrace("High authentication failed. ", DLMS_ERROR_CODE_INVALID_PARAMETER);
#endif //DLMS_DEBUG
return DLMS_ERROR_CODE_INVALID_PARAMETER;
}
#endif //DLMS_IGNORE_MALLOC
#ifndef DLMS_IGNORE_HIGH_GMAC
if (settings->base.authentication == DLMS_AUTHENTICATION_HIGH_GMAC)
{
bb_attach(&tmp, settings->base.sourceSystemTitle, sizeof(settings->base.sourceSystemTitle), sizeof(settings->base.sourceSystemTitle));
if ((ret = bb_getUInt8(e->parameters.byteArr, &ch)) != 0 ||
(ret = bb_getUInt32(e->parameters.byteArr, &ic)) != 0)
{
return ret;
}
//IC is also compared.
e->parameters.byteArr->position -= 5;
readSecret = &tmp;
}
else
#endif //DLMS_IGNORE_MALLOC
{
readSecret = &object->secret;
}
BYTE_BUFFER_INIT(&bb);
bb_attach(&bb, tmp2, 0, sizeof(tmp2));
if ((ret = dlms_secure(&settings->base,
ic,
&settings->base.stoCChallenge,
readSecret,
&bb)) != 0)
{
return ret;
}
equal = bb_available(e->parameters.byteArr) != 0 &&
bb_compare(&bb,
e->parameters.byteArr->data + e->parameters.byteArr->position,
bb_available(e->parameters.byteArr));
bb_clear(&settings->info.data);
if (equal)
{
#ifndef DLMS_IGNORE_HIGH_GMAC
if (settings->base.authentication == DLMS_AUTHENTICATION_HIGH_GMAC)
{
#ifdef DLMS_IGNORE_MALLOC
bb_attach(&tmp, settings->base.cipher.systemTitle, sizeof(settings->base.cipher.systemTitle), sizeof(settings->base.cipher.systemTitle));
readSecret = &tmp;
#else
readSecret = &settings->base.cipher.systemTitle;
#endif //DLMS_IGNORE_MALLOC
ic = settings->base.cipher.invocationCounter;
}
#endif //DLMS_IGNORE_HIGH_GMAC
e->byteArray = 1;
if ((ret = dlms_secure(&settings->base,
ic,
&settings->base.ctoSChallenge,
readSecret,
&settings->info.data)) != 0)
{
return ret;
}
bb_insertUInt8(&settings->info.data, 0, DLMS_DATA_TYPE_OCTET_STRING);
bb_insertUInt8(&settings->info.data, 1, (unsigned char)(settings->info.data.size - 1));
object->associationStatus = DLMS_ASSOCIATION_STATUS_ASSOCIATED;
}
else
{
object->associationStatus = DLMS_ASSOCIATION_STATUS_NON_ASSOCIATED;
ret = DLMS_ERROR_CODE_READ_WRITE_DENIED;
}
}
else if (e->index == 2)
{
#ifdef DLMS_IGNORE_MALLOC
ret = cosem_getOctetString(e->parameters.byteArr, &object->secret);
#else
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
uint32_t size = bb_available(e->parameters.byteArr);
#else
uint16_t size = bb_available(e->parameters.byteArr);
#endif
if (size == 0)
{
ret = DLMS_ERROR_CODE_INCONSISTENT_CLASS_OR_OBJECT;
}
else
{
bb_clear(&object->secret);
ret = bb_set(&object->secret, e->parameters.byteArr->data + e->parameters.byteArr->position, size);
}
#endif //DLMS_IGNORE_MALLOC
}
else if (e->index == 5)
{
#ifdef DLMS_IGNORE_MALLOC
gxUser* it;
if (!(object->userList.size < arr_getCapacity(&object->userList)))
{
ret = DLMS_ERROR_CODE_INVALID_PARAMETER;
}
else
{
++object->userList.size;
if ((ret = arr_getByIndex(&object->userList, object->userList.size - 1, (void**)&it, sizeof(gxUser))) == 0)
{
if ((ret = cosem_checkStructure(e->parameters.byteArr, 2)) != 0 ||
(ret = cosem_getUInt8(e->parameters.byteArr, &it->id)) != 0 ||
(ret = cosem_getString2(e->parameters.byteArr, it->name, sizeof(it->name))) != 0)
{
//Error code is returned at the end of the function.
}
}
}
#else
if (e->parameters.vt != DLMS_DATA_TYPE_STRUCTURE || e->parameters.Arr->size != 2)
{
ret = DLMS_ERROR_CODE_INCONSISTENT_CLASS_OR_OBJECT;
}
else
{
dlmsVARIANT* tmp;
char* name;
gxKey2* it = (gxKey2*)gxmalloc(sizeof(gxKey2));
if ((ret = va_getByIndex(e->parameters.Arr, 0, &tmp)) != 0)
{
gxfree(it);
return ret;
}
it->key = tmp->bVal;
if ((ret = va_getByIndex(e->parameters.Arr, 1, &tmp)) != 0)
{
gxfree(it);
return ret;
}
name = gxmalloc(tmp->strVal->size + 1);
it->value = name;
*(name + tmp->strVal->size) = '\0';
memcpy(it->value, tmp->strVal->data, tmp->strVal->size);
ret = arr_push(&((gxAssociationLogicalName*)e->target)->userList, it);
}
#endif //DLMS_IGNORE_MALLOC
}
else if (e->index == 6)
{
int pos;
#ifdef DLMS_IGNORE_MALLOC
gxUser* it;
unsigned char id;
char name[MAX_SAP_ITEM_NAME_LENGTH];
if ((ret = cosem_checkStructure(e->parameters.byteArr, 2)) == 0 &&
(ret = cosem_getUInt8(e->parameters.byteArr, &id)) == 0 &&
(ret = cosem_getString2(e->parameters.byteArr, name, sizeof(name))) == 0)
{
uint16_t size = (uint16_t)strlen(name);
for (pos = 0; pos != ((gxAssociationLogicalName*)e->target)->userList.size; ++pos)
{
if ((ret = arr_getByIndex(&((gxAssociationLogicalName*)e->target)->userList, pos, (void**)&it, sizeof(gxUser))) != 0)
{
return ret;
}
if (it->id == id && memcmp(it->name, name, size) == 0)
{
int pos2;
gxUser* it2;
for (pos2 = pos + 1; pos2 < ((gxAssociationLogicalName*)e->target)->userList.size; ++pos2)
{
if ((ret = arr_getByIndex(&((gxAssociationLogicalName*)e->target)->userList, pos2, (void**)&it2, sizeof(gxUser))) != 0)
{
break;
}
memcpy(it, it2, sizeof(gxUser));
it = it2;
}
--((gxAssociationLogicalName*)e->target)->userList.size;
break;
}
}
}
#else
if (e->parameters.Arr->size != 2)
{
return DLMS_ERROR_CODE_INCONSISTENT_CLASS_OR_OBJECT;
}
else
{
gxKey2* it;
unsigned char id;
dlmsVARIANT* tmp;
unsigned char* name;
ret = va_getByIndex(e->parameters.Arr, 0, &tmp);
id = tmp->bVal;
ret = va_getByIndex(e->parameters.Arr, 1, &tmp);
name = tmp->strVal->data;
int len = tmp->strVal->size;
for (pos = 0; pos != ((gxAssociationLogicalName*)e->target)->userList.size; ++pos)
{
ret = arr_getByIndex(&((gxAssociationLogicalName*)e->target)->userList, pos, (void**)&it);
if (ret != 0)
{
return ret;
}
if (it->key == id && memcmp(it->value, name, len) == 0)
{
ret = arr_removeByIndex(&((gxAssociationLogicalName*)e->target)->userList, pos, (void**)&it);
gxfree(it->value);
gxfree(it);
break;
}
}
}
#endif //DLMS_IGNORE_MALLOC
}
else
{
ret = DLMS_ERROR_CODE_READ_WRITE_DENIED;
}
return ret;
}
#endif //DLMS_IGNORE_ASSOCIATION_LOGICAL_NAME
#ifndef DLMS_IGNORE_IMAGE_TRANSFER
int invoke_ImageTransfer(
gxImageTransfer* target,
gxValueEventArg* e)
{
int pos, ret = 0;
//Image transfer initiate
if (e->index == 1)
{
gxByteBuffer tmp;
gxImageActivateInfo* it, * item = NULL;
target->imageFirstNotTransferredBlockNumber = 0;
ba_clear(&target->imageTransferredBlocksStatus);
dlmsVARIANT* imageIdentifier, * size;
#ifdef DLMS_IGNORE_MALLOC
dlmsVARIANT imageIdentifier2, size2;
uint16_t count;
unsigned char ch;
if ((ret = cosem_checkStructure(e->parameters.byteArr, 2)) != 0 ||
(ret = bb_getUInt8(e->parameters.byteArr, &ch)) != 0 ||
ch != DLMS_DATA_TYPE_OCTET_STRING ||
(ret = hlp_getObjectCount2(e->parameters.byteArr, &count)) != 0)
{
e->error = DLMS_ERROR_CODE_HARDWARE_FAULT;
return ret;
}
imageIdentifier2.vt = DLMS_DATA_TYPE_OCTET_STRING;
size2.vt = DLMS_DATA_TYPE_UINT32;
//Attach image identifier so heap is not used.
gxByteBuffer bb;
bb_attach(&bb, e->parameters.byteArr->data + e->parameters.byteArr->position, count, count);
imageIdentifier2.byteArr = &bb;
e->parameters.byteArr->position += count;
if ((ret = cosem_getUInt32(e->parameters.byteArr, &size2.ulVal)) != 0)
{
e->error = DLMS_ERROR_CODE_HARDWARE_FAULT;
return ret;
}
imageIdentifier = &imageIdentifier2;
size = &size2;
#else
if ((ret = va_getByIndex(e->parameters.Arr, 0, &imageIdentifier)) != 0 ||
(ret = va_getByIndex(e->parameters.Arr, 1, &size)) != 0)
{
e->error = DLMS_ERROR_CODE_HARDWARE_FAULT;
return ret;
}
#endif //DLMS_IGNORE_MALLOC
target->imageTransferStatus = DLMS_IMAGE_TRANSFER_STATUS_INITIATED;
unsigned char exists = 0;
for (pos = 0; pos != target->imageActivateInfo.size; ++pos)
{
#ifdef DLMS_IGNORE_MALLOC
if ((ret = arr_getByIndex(&target->imageActivateInfo, pos, (void**)&it, sizeof(gxImageActivateInfo))) != 0)
{
return ret;
}
#else
if ((ret = arr_getByIndex(&target->imageActivateInfo, pos, (void**)&it)) != 0)
{
return ret;
}
#endif //DLMS_IGNORE_MALLOC
bb_attach(&tmp, it->identification.data, it->identification.size, it->identification.size);
if (bb_size(imageIdentifier->byteArr) != 0 &&
bb_compare(&tmp, imageIdentifier->byteArr->data, imageIdentifier->byteArr->size))
{
item = it;
exists = 1;
}
}
if (!exists)
{
#ifdef DLMS_IGNORE_MALLOC
++target->imageActivateInfo.size;
if ((ret = arr_getByIndex(&target->imageActivateInfo, pos, (void**)&item, sizeof(gxImageActivateInfo))) != 0)
{
--target->imageActivateInfo.size;
return ret;
}
#else
item = (gxImageActivateInfo*)gxmalloc(sizeof(gxImageActivateInfo));
BYTE_BUFFER_INIT(&item->identification);
BYTE_BUFFER_INIT(&item->signature);
arr_push(&target->imageActivateInfo, item);
#endif //DLMS_IGNORE_MALLOC
item->size = var_toInteger(size);
#ifdef DLMS_IGNORE_MALLOC
item->identification.size = (uint16_t)imageIdentifier->byteArr->size;
if ((ret = bb_get(imageIdentifier->byteArr, item->identification.data, imageIdentifier->byteArr->size)) != 0)
{
return ret;
}
#else
item->identification.size = 0;
if ((ret = bb_set2(&item->identification, imageIdentifier->byteArr, 0, bb_size(imageIdentifier->byteArr))) != 0)
{
return ret;
}
#endif //DLMS_IGNORE_MALLOC
uint16_t cnt = (uint16_t)(item->size / target->imageBlockSize);
if (item->size % target->imageBlockSize != 0)
{
++cnt;
}
cnt = ba_getByteCount(cnt);
#ifndef GX_DLMS_MICROCONTROLLER
target->imageTransferredBlocksStatus.position = 0;
#endif //GX_DLMS_MICROCONTROLLER
#ifdef DLMS_IGNORE_MALLOC
//Image transferred blocks status must handle in server side when malloc is not used if image size is huge.
if (target->imageTransferredBlocksStatus.capacity != 0)
{
if (cnt > ba_getCapacity(&target->imageTransferredBlocksStatus))
{
e->error = DLMS_ERROR_CODE_HARDWARE_FAULT;
return ret;
}
else
{
target->imageTransferredBlocksStatus.size = 0;
if ((ret = ba_capacity(&target->imageTransferredBlocksStatus, cnt)) == 0)
{
for (pos = 0; pos != cnt; ++pos)
{
ba_set(&target->imageTransferredBlocksStatus, 0);
}
}
}
}
#else
target->imageTransferredBlocksStatus.size = 0;
if ((ret = ba_capacity(&target->imageTransferredBlocksStatus, cnt)) == 0)
{
for (pos = 0; pos != cnt; ++pos)
{
ba_set(&target->imageTransferredBlocksStatus, 0);
}
}
#endif //DLMS_IGNORE_MALLOC
}
}
//Image block transfer
else if (e->index == 2)
{
uint32_t index;
#ifdef DLMS_IGNORE_MALLOC
if ((ret = cosem_checkStructure(e->parameters.byteArr, 2)) != 0 ||
(ret = cosem_getUInt32(e->parameters.byteArr, &index)) != 0)
{
e->error = DLMS_ERROR_CODE_HARDWARE_FAULT;
return ret;
}
#else
dlmsVARIANT* imageIndex;
if ((ret = va_getByIndex(e->parameters.Arr, 0, &imageIndex)) != 0)
{
e->error = DLMS_ERROR_CODE_HARDWARE_FAULT;
return ret;
}
index = (uint16_t)var_toInteger(imageIndex);
#endif //DLMS_IGNORE_MALLOC
if ((ret = ba_setByIndex(&target->imageTransferredBlocksStatus, (uint16_t)index, 1)) == 0)
{
target->imageFirstNotTransferredBlockNumber = index + 1;
target->imageTransferStatus = DLMS_IMAGE_TRANSFER_STATUS_INITIATED;
}
#ifdef DLMS_IGNORE_MALLOC
bb_clear(e->parameters.byteArr);
#endif //DLMS_IGNORE_MALLOC
}
//Image verify
else if (e->index == 3)
{
ret = 0;
}
//Image activate.
else if (e->index == 4)
{
ret = 0;
}
else
{
ret = DLMS_ERROR_CODE_READ_WRITE_DENIED;
}
return ret;
}
#endif //DLMS_IGNORE_IMAGE_TRANSFER
#ifndef DLMS_IGNORE_SAP_ASSIGNMENT
int invoke_SapAssigment(
gxSapAssignment* target,
gxValueEventArg* e)
{
int pos, ret = 0;
uint16_t id;
gxSapItem* it;
//Image transfer initiate
if (e->index == 1)
{
#ifdef DLMS_IGNORE_MALLOC
if (e->parameters.vt != DLMS_DATA_TYPE_OCTET_STRING)
{
ret = DLMS_ERROR_CODE_INCONSISTENT_CLASS_OR_OBJECT;
}
else if ((ret = cosem_checkStructure(e->parameters.byteArr, 2)) == 0 &&
(ret = cosem_getUInt16(e->parameters.byteArr, &id)) == 0)
{
if (id == 0)
{
uint16_t size;
unsigned char name[MAX_SAP_ITEM_NAME_LENGTH];
if ((ret = cosem_getOctetString2(e->parameters.byteArr, name, sizeof(name), &size)) == 0)
{
name[size] = 0;
for (pos = 0; pos != target->sapAssignmentList.size; ++pos)
{
if ((ret = arr_getByIndex(&target->sapAssignmentList, pos, (void**)&it, sizeof(gxSapItem))) != 0)
{
return ret;
}
if (it->name.size == size && memcmp(it->name.value, name, size) == 0)
{
if ((ret = arr_removeByIndex(&target->sapAssignmentList, pos, sizeof(gxSapItem))) == 0)
{
//arr_removeByIndex is decreasing amount already.
break;
}
}
}
}
}
else
{
//If buffer is full.
if (!(target->sapAssignmentList.size < target->sapAssignmentList.capacity))
{
ret = DLMS_ERROR_CODE_INCONSISTENT_CLASS_OR_OBJECT;
}
else
{
++target->sapAssignmentList.size;
if ((ret = arr_getByIndex(&target->sapAssignmentList, target->sapAssignmentList.size - 1, (void**)&it, sizeof(gxSapItem))) == 0 &&
(ret = cosem_getOctetString2(e->parameters.byteArr, it->name.value, sizeof(it->name.value), &it->name.size)) == 0)
{
it->id = id;
}
else
{
--target->sapAssignmentList.size;
}
}
}
}
#else
dlmsVARIANT* tmp;
if ((ret = va_getByIndex(e->parameters.Arr, 0, &tmp)) != 0)
{
return ret;
}
id = tmp->uiVal;
if ((ret = va_getByIndex(e->parameters.Arr, 1, &tmp)) != 0)
{
return ret;
}
gxByteBuffer* name;
if (tmp->vt == DLMS_DATA_TYPE_OCTET_STRING)
{
name = tmp->byteArr;
}
else
{
name = tmp->strVal;
}
if (id == 0)
{
for (pos = 0; pos != target->sapAssignmentList.size; ++pos)
{
if ((ret = arr_getByIndex(&target->sapAssignmentList, pos, (void**)&it)) != 0)
{
return ret;
}
it->name.position = 0;
if (name != NULL && bb_compare(&it->name, name->data, bb_size(name)))
{
ret = arr_removeByIndex(&target->sapAssignmentList, pos, (void**)&it);
bb_clear(&it->name);
gxfree(it);
return ret;
}
}
}
else
{
it = (gxSapItem*)gxmalloc(sizeof(gxSapItem));
it->id = id;
BYTE_BUFFER_INIT(&it->name);
bb_set(&it->name, name->data, name->size);
arr_push(&target->sapAssignmentList, it);
}
#endif //DLMS_IGNORE_MALLOC
}
else
{
ret = DLMS_ERROR_CODE_READ_WRITE_DENIED;
}
return ret;
}
#endif //DLMS_IGNORE_SAP_ASSIGNMENT
#ifndef DLMS_IGNORE_SECURITY_SETUP
int invoke_SecuritySetup(dlmsServerSettings* settings, gxSecuritySetup* target, gxValueEventArg* e)
{
int ret = 0;
#ifndef DLMS_IGNORE_HIGH_GMAC
int pos;
#endif //DLMS_IGNORE_HIGH_GMAC
if (e->index == 1)
{
//The security policy can only be strengthened.
if (target->securityPolicy > var_toInteger(&e->parameters))
{
ret = DLMS_ERROR_CODE_INCONSISTENT_CLASS_OR_OBJECT;
}
else
{
target->securityPolicy = var_toInteger(&e->parameters);
}
}
else if (e->index == 2)
{
#ifdef DLMS_IGNORE_HIGH_GMAC
ret = DLMS_ERROR_CODE_INCONSISTENT_CLASS_OR_OBJECT;
#else
#ifdef DLMS_IGNORE_MALLOC
if (e->parameters.vt != DLMS_DATA_TYPE_OCTET_STRING)
{
ret = DLMS_ERROR_CODE_INCONSISTENT_CLASS_OR_OBJECT;
}
else
{
unsigned char TMP[24];
gxByteBuffer tmp;
BB_ATTACH(tmp, TMP, 0);
unsigned char BUFF[24];
gxByteBuffer bb;
BB_ATTACH(bb, BUFF, 0);
unsigned char type;
uint16_t count = 10;
if ((ret = cosem_checkArray(e->parameters.byteArr, &count)) == 0)
{
for (pos = 0; pos != count; ++pos)
{
if ((ret = cosem_checkStructure(e->parameters.byteArr, 2)) != 0 ||
(ret = cosem_getEnum(e->parameters.byteArr, &type)) != 0 ||
(ret = cosem_getOctetString(e->parameters.byteArr, &tmp)) != 0 ||
(ret = cip_decryptKey(settings->base.kek, sizeof(settings->base.kek), &tmp, &bb)) != 0)
{
break;
}
if (bb.size != 16)
{
e->error = DLMS_ERROR_CODE_INCONSISTENT_CLASS_OR_OBJECT;
break;
}
switch (type)
{
case DLMS_GLOBAL_KEY_TYPE_UNICAST_ENCRYPTION:
memcpy(settings->base.cipher.blockCipherKey, BUFF, bb.size);
break;
case DLMS_GLOBAL_KEY_TYPE_BROADCAST_ENCRYPTION:
//Invalid type
ret = DLMS_ERROR_CODE_INCONSISTENT_CLASS_OR_OBJECT;
break;
case DLMS_GLOBAL_KEY_TYPE_AUTHENTICATION:
memcpy(settings->base.cipher.authenticationKey, BUFF, bb.size);
break;
case DLMS_GLOBAL_KEY_TYPE_KEK:
memcpy(settings->base.kek, BUFF, bb.size);
break;
default:
//Invalid type
ret = DLMS_ERROR_CODE_INCONSISTENT_CLASS_OR_OBJECT;
break;
}
}
}
}
#else
dlmsVARIANT* it, * type, * data;
if (e->parameters.vt != DLMS_DATA_TYPE_ARRAY)
{
ret = DLMS_ERROR_CODE_INCONSISTENT_CLASS_OR_OBJECT;
}
else
{
gxByteBuffer bb;
BYTE_BUFFER_INIT(&bb);
for (pos = 0; pos != e->parameters.Arr->size; ++pos)
{
bb_clear(&bb);
if ((ret = va_getByIndex(e->parameters.Arr, pos, &it)) != 0 ||
(ret = va_getByIndex(it->Arr, 0, &type)) != 0 ||
(ret = va_getByIndex(it->Arr, 1, &data)) != 0 ||
(ret = cip_decryptKey(settings->base.kek.data, (unsigned char)settings->base.kek.size, data->byteArr, &bb)) != 0)
{
break;
}
if (bb.size != 16)
{
e->error = DLMS_ERROR_CODE_INCONSISTENT_CLASS_OR_OBJECT;
break;
}
switch (type->cVal)
{
case DLMS_GLOBAL_KEY_TYPE_UNICAST_ENCRYPTION:
bb_clear(&settings->base.cipher.blockCipherKey);
bb_set(&settings->base.cipher.blockCipherKey, bb.data, bb.size);
break;
case DLMS_GLOBAL_KEY_TYPE_BROADCAST_ENCRYPTION:
//Invalid type
ret = DLMS_ERROR_CODE_INCONSISTENT_CLASS_OR_OBJECT;
break;
case DLMS_GLOBAL_KEY_TYPE_AUTHENTICATION:
bb_clear(&settings->base.cipher.authenticationKey);
bb_set(&settings->base.cipher.authenticationKey, bb.data, bb.size);
break;
case DLMS_GLOBAL_KEY_TYPE_KEK:
bb_clear(&settings->base.kek);
bb_set(&settings->base.kek, bb.data, bb.size);
break;
default:
//Invalid type
ret = DLMS_ERROR_CODE_INCONSISTENT_CLASS_OR_OBJECT;
break;
}
}
bb_clear(&bb);
}
#endif //DLMS_IGNORE_MALLOC
#endif //DLMS_IGNORE_HIGH_GMAC
}
else
{
ret = DLMS_ERROR_CODE_READ_WRITE_DENIED;
}
return ret;
}
#endif //DLMS_IGNORE_SECURITY_SETUP
#ifndef DLMS_IGNORE_ASSOCIATION_SHORT_NAME
int invoke_AssociationShortName(
dlmsServerSettings* settings,
gxValueEventArg* e)
{
int ret;
unsigned char equal;
uint32_t ic = 0;
#ifndef DLMS_IGNORE_HIGH_GMAC
gxByteBuffer bb;
#endif //DLMS_IGNORE_HIGH_GMAC
gxByteBuffer* readSecret;
// Check reply_to_HLS_authentication
if (e->index == 8)
{
#ifndef DLMS_IGNORE_HIGH_GMAC
if (settings->base.authentication == DLMS_AUTHENTICATION_HIGH_GMAC)
{
unsigned char ch;
bb_attach(&bb, settings->base.sourceSystemTitle, sizeof(settings->base.sourceSystemTitle), sizeof(settings->base.sourceSystemTitle));
readSecret = &bb;
if ((ret = bb_getUInt8(&settings->info.data, &ch)) != 0 ||
(ret = bb_getUInt32(&settings->info.data, &ic)) != 0)
{
bb_clear(&settings->info.data);
return ret;
}
}
else
#endif //DLMS_IGNORE_HIGH_GMAC
{
readSecret = &((gxAssociationShortName*)e->target)->secret;
}
bb_clear(&settings->info.data);
if ((ret = dlms_secure(&settings->base, ic,
&settings->base.stoCChallenge, readSecret, &settings->info.data)) != 0)
{
bb_clear(&settings->info.data);
return ret;
}
equal = bb_size(e->parameters.byteArr) != 0 &&
bb_compare(&settings->info.data,
e->parameters.byteArr->data,
e->parameters.byteArr->size);
bb_clear(&settings->info.data);
if (equal)
{
e->byteArray = 1;
#ifndef DLMS_IGNORE_HIGH_GMAC
if (settings->base.authentication == DLMS_AUTHENTICATION_HIGH_GMAC)
{
#ifdef DLMS_IGNORE_MALLOC
bb_attach(&bb, settings->base.cipher.systemTitle, sizeof(settings->base.cipher.systemTitle), sizeof(settings->base.cipher.systemTitle));
readSecret = &bb;
#else
readSecret = &settings->base.cipher.systemTitle;
#endif //DLMS_IGNORE_MALLOC
ic = settings->base.cipher.invocationCounter;
}
#endif //DLMS_IGNORE_HIGH_GMAC
if ((ret = dlms_secure(&settings->base,
ic,
&settings->base.ctoSChallenge,
readSecret,
&settings->info.data)) != 0)
{
return ret;
}
bb_insertUInt8(&settings->info.data, 0, DLMS_DATA_TYPE_OCTET_STRING);
bb_insertUInt8(&settings->info.data, 1, (unsigned char)(settings->info.data.size - 1));
}
else
{
return 0;
}
}
else
{
return DLMS_ERROR_CODE_READ_WRITE_DENIED;
}
return 0;
}
#endif //DLMS_IGNORE_ASSOCIATION_SHORT_NAME
#ifndef DLMS_IGNORE_SCRIPT_TABLE
int invoke_ScriptTable(
dlmsServerSettings* settings,
gxValueEventArg* e)
{
gxScript* s;
gxScriptAction* sa;
gxValueEventArg* e1;
int ret = 0, pos, pos2;
unsigned char id = var_toInteger(&e->parameters);
//Find index and execute it.
if (e->index == 1)
{
gxValueEventCollection args;
#ifdef DLMS_IGNORE_MALLOC
gxValueEventArg tmp[1];
ve_init(&tmp[0]);
vec_attach(&args, tmp, 1, 1);
e1 = &tmp[0];
#else
e1 = (gxValueEventArg*)gxmalloc(sizeof(gxValueEventArg));
ve_init(e1);
vec_init(&args);
vec_push(&args, e1);
#endif //DLMS_IGNORE_MALLOC
for (pos = 0; pos != ((gxScriptTable*)e->target)->scripts.size; ++pos)
{
#ifdef DLMS_IGNORE_MALLOC
if ((ret = arr_getByIndex(&((gxScriptTable*)e->target)->scripts, pos, (void**)&s, sizeof(gxScript))) != 0)
#else
if ((ret = arr_getByIndex(&((gxScriptTable*)e->target)->scripts, pos, (void**)&s)) != 0)
#endif //DLMS_IGNORE_MALLOC
{
break;
}
if (s->id == id)
{
for (pos2 = 0; pos2 != s->actions.size; ++pos2)
{
#ifdef DLMS_IGNORE_MALLOC
if ((ret = arr_getByIndex(&s->actions, pos2, (void**)&sa, sizeof(gxScriptAction))) != 0)
#else
if ((ret = arr_getByIndex(&s->actions, pos2, (void**)&sa)) != 0)
#endif //DLMS_IGNORE_MALLOC
{
break;
}
if (sa->type == DLMS_SCRIPT_ACTION_TYPE_WRITE)
{
e1->value = sa->parameter;
}
else
{
e1->parameters = sa->parameter;
}
e1->index = sa->index;
#ifndef DLMS_IGNORE_OBJECT_POINTERS
e1->target = sa->target;
#else
if ((ret = oa_findByLN(&settings->base.objects, sa->objectType, sa->logicalName, &e1->target)) != 0)
{
break;
}
if (e1->target == NULL)
{
ret = DLMS_ERROR_CODE_INCONSISTENT_CLASS_OR_OBJECT;
break;
}
#endif //DLMS_IGNORE_OBJECT_POINTERS
if (sa->type == DLMS_SCRIPT_ACTION_TYPE_WRITE)
{
svr_preWrite(&settings->base, &args);
if (e1->error != 0)
{
ret = e1->error;
}
else if (!e1->handled)
{
//Set action to true to indicate that this is called from the action method.
e1->action = 1;
if ((ret = cosem_setValue(&settings->base, e1)) != 0)
{
break;
}
svr_postWrite(&settings->base, &args);
if (e1->error != 0)
{
ret = e1->error;
}
}
}
else if (sa->type == DLMS_SCRIPT_ACTION_TYPE_EXECUTE)
{
svr_preAction(&settings->base, &args);
if (e1->error != 0)
{
ret = e1->error;
}
else if (!e1->handled)
{
if ((ret = cosem_invoke(settings, e1)) != 0)
{
break;
}
svr_postAction(&settings->base, &args);
if (e1->error != 0)
{
ret = e1->error;
}
}
}
else
{
ret = DLMS_ERROR_CODE_INCONSISTENT_CLASS_OR_OBJECT;
}
if (ret != 0)
{
break;
}
}
}
}
vec_clear(&args);
}
else
{
ret = DLMS_ERROR_CODE_INCONSISTENT_CLASS_OR_OBJECT;
}
var_clear(&e->value);
return ret;
}
#endif //DLMS_IGNORE_SCRIPT_TABLE
#ifndef DLMS_IGNORE_ZIG_BEE_NETWORK_CONTROL
int invoke_zigbeeNetworkControl(gxZigBeeNetworkControl* object, unsigned char index, dlmsVARIANT* value)
{
int ret = 0, pos;
#ifndef DLMS_IGNORE_MALLOC
dlmsVARIANT* it;
#endif //DLMS_IGNORE_MALLOC
gxActiveDevice* ad;
uint32_t v;
//Register device.
if (index == 1)
{
#ifdef DLMS_IGNORE_MALLOC
if ((ret = arr_getByIndex(&object->activeDevices, object->activeDevices.size, (void**)&ad, sizeof(gxActiveDevice))) == 0)
{
++object->activeDevices.size;
BYTE_BUFFER_INIT(&ad->macAddress);
if ((ret = cosem_getOctetString(value->byteArr, &ad->macAddress)) == 0 &&
(ret = cosem_getIntegerFromBitString(value->byteArr, &v)) == 0)
{
ad->status = (DLMS_ZIG_BEE_STATUS)v;
}
}
#else
if ((ret = va_getByIndex(value->Arr, 0, &it)) == 0)
{
ad = (gxActiveDevice*)gxcalloc(1, sizeof(gxActiveDevice));
BYTE_BUFFER_INIT(&ad->macAddress);
if ((ret = bb_set(&ad->macAddress, it->byteArr->data, it->byteArr->size)) == 0 &&
(ret = cosem_getIntegerFromBitString(it->byteArr, &v)) == 0)
{
ad->status = (DLMS_ZIG_BEE_STATUS)v;
arr_push(&object->activeDevices, ad);
}
else
{
gxfree(ad);
}
}
#endif //DLMS_IGNORE_MALLOC
}
//Unregister device.
else if (index == 2)
{
for (pos = 0; pos != object->activeDevices.size; ++pos)
{
#ifdef DLMS_IGNORE_MALLOC
if ((ret = arr_getByIndex(&object->activeDevices, pos, (void**)&ad, sizeof(gxActiveDevice))) != 0)
{
break;
}
if (memcpy(&ad->macAddress, &value->byteArr, 8) == 0)
{
int pos2;
gxActiveDevice* ad2;
for (pos2 = pos + 1; pos2 < object->activeDevices.size; ++pos2)
{
if ((ret = arr_getByIndex(&object->activeDevices, pos2, (void**)&ad2, sizeof(gxActiveDevice))) != 0)
{
break;
}
memcpy(ad, ad2, sizeof(gxActiveDevice));
ad = ad2;
}
--object->activeDevices.size;
break;
}
#else
ret = arr_getByIndex(&object->activeDevices, pos, (void**)&ad);
if (ret != 0)
{
return ret;
}
if (memcpy(&ad->macAddress, &value->byteArr, 8) == 0)
{
ret = arr_removeByIndex(&object->activeDevices, pos, (void**)&ad);
if (ret != 0)
{
return ret;
}
gxfree(ad);
break;
}
#endif //DLMS_IGNORE_MALLOC
}
}
//Unregister all device.
else if (index == 3)
{
ret = obj_clearActiveDevices(&object->activeDevices);
}
//backup PAN
else if (index == 4)
{
}
//Restore PAN,
else if (index == 5)
{
// This method instructs the coordinator to restore a PAN using backup information.
// The storage location of the back-up is not currently defined and is an internal function
// of the DLMS/COSEM Server.
}
else
{
ret = DLMS_ERROR_CODE_INVALID_PARAMETER;
}
return ret;
}
#endif //DLMS_IGNORE_ZIG_BEE_NETWORK_CONTROL
#ifndef DLMS_IGNORE_EXTENDED_REGISTER
int invoke_ExtendedRegister(
dlmsServerSettings* settings,
gxExtendedRegister* object,
unsigned char index)
{
int ret = 0;
//Reset.
if (index == 1)
{
ret = var_clear(&object->value);
if (ret != 0)
{
return ret;
}
if (settings->defaultClock != NULL)
{
object->captureTime = settings->defaultClock->time;
}
else
{
time_clear(&object->captureTime);
}
}
else
{
ret = DLMS_ERROR_CODE_INVALID_PARAMETER;
}
return ret;
}
#endif //DLMS_IGNORE_EXTENDED_REGISTER
#ifndef DLMS_IGNORE_DEMAND_REGISTER
int invoke_DemandRegister(
dlmsServerSettings* settings,
gxDemandRegister* object,
unsigned char index)
{
int ret = 0;
//Reset.
if (index == 1)
{
if ((ret = var_clear(&object->currentAverageValue)) != 0 ||
(ret = var_clear(&object->lastAverageValue)) != 0)
{
return ret;
}
if (settings->defaultClock != NULL)
{
object->startTimeCurrent = object->captureTime = settings->defaultClock->time;
}
else
{
time_clear(&object->captureTime);
time_clear(&object->startTimeCurrent);
}
}
else if (index == 1)
{
if ((ret = var_copy(&object->lastAverageValue, &object->currentAverageValue)) != 0 ||
(ret = var_clear(&object->currentAverageValue)) != 0)
{
return ret;
}
if (settings->defaultClock != NULL)
{
object->startTimeCurrent = object->captureTime = settings->defaultClock->time;
}
else
{
time_clear(&object->captureTime);
time_clear(&object->startTimeCurrent);
}
}
else
{
ret = DLMS_ERROR_CODE_INVALID_PARAMETER;
}
return ret;
}
#endif //DLMS_IGNORE_DEMAND_REGISTER
#ifndef DLMS_IGNORE_CLOCK
int invoke_Clock(gxClock* object, unsigned char index, dlmsVARIANT* value)
{
int ret = 0;
#ifndef DLMS_IGNORE_MALLOC
dlmsVARIANT* it;
dlmsVARIANT tmp;
#endif //DLMS_IGNORE_MALLOC
// Resets the value to the default value.
// The default value is an instance specific constant.
if (index == 1)
{
#ifdef DLMS_USE_EPOCH_TIME
int minutes = time_getMinutes(&object->time);
#else
int minutes = object->time.value.tm_min;
#endif // DLMS_USE_EPOCH_TIME
if (minutes < 8)
{
minutes = 0;
}
else if (minutes < 23)
{
minutes = 15;
}
else if (minutes < 38)
{
minutes = 30;
}
else if (minutes < 53)
{
minutes = 45;
}
else
{
minutes = 0;
time_addHours(&object->time, 1);
}
#ifdef DLMS_USE_EPOCH_TIME
time_addTime(&object->time, 0, -time_getMinutes(&object->time) + minutes, -time_getSeconds(&object->time));
#else
time_addTime(&object->time, 0, -object->time.value.tm_min + minutes, -object->time.value.tm_sec);
#endif // DLMS_USE_EPOCH_TIME
}
// Sets the meter's time to the nearest minute.
else if (index == 3)
{
#ifdef DLMS_USE_EPOCH_TIME
int s = time_getSeconds(&object->time);
#else
int s = object->time.value.tm_sec;
#endif // DLMS_USE_EPOCH_TIME
if (s > 30)
{
time_addTime(&object->time, 0, 1, 0);
}
time_addTime(&object->time, 0, 0, -s);
}
//Adjust to preset time.
else if (index == 4)
{
object->time = object->presetTime;
}
// Presets the time to a new value (preset_time) and defines
// avalidity_interval within which the new time can be activated.
else if (index == 5)
{
#ifdef DLMS_IGNORE_MALLOC
ret = cosem_getDateFromOctetString(value->byteArr, &object->presetTime);
#else
ret = var_init(&tmp);
if (ret != 0)
{
return ret;
}
ret = va_getByIndex(value->Arr, 0, &it);
if (ret != 0)
{
return ret;
}
ret = dlms_changeType2(it, DLMS_DATA_TYPE_DATETIME, &tmp);
if (ret != 0)
{
return ret;
}
object->presetTime = *tmp.dateTime;
#endif //DLMS_IGNORE_MALLOC
}
// Shifts the time.
else if (index == 6)
{
time_addTime(&object->time, 0, 0, var_toInteger(value));
}
else
{
ret = DLMS_ERROR_CODE_INVALID_PARAMETER;
}
return ret;
}
#endif //DLMS_IGNORE_CLOCK
#ifndef DLMS_IGNORE_REGISTER
int invoke_Register(
gxRegister* object,
gxValueEventArg* e)
{
int ret = 0;
//Reset.
if (e->index == 1)
{
ret = var_clear(&object->value);
}
else
{
ret = DLMS_ERROR_CODE_INVALID_PARAMETER;
}
return ret;
}
#endif //DLMS_IGNORE_REGISTER
#ifndef DLMS_IGNORE_PROFILE_GENERIC
/*
* Copies the values of the objects to capture into the buffer by reading
* capture objects.
*/
int capture(dlmsSettings* settings,
gxProfileGeneric* object)
{
#ifdef DLMS_IGNORE_MALLOC
gxValueEventArg e;
gxValueEventCollection args;
ve_init(&e);
e.action = 1;
e.target = &object->base;
e.index = 2;
gxValueEventArg p[1] = { e };
vec_attach(&args, p, 1, 1);
svr_preGet(settings, &args);
svr_postGet(settings, &args);
vec_empty(&args);
#else
int ret, pos;
gxKey* kv;
dlmsVARIANT* value;
variantArray* row;
gxValueEventArg e;
gxValueEventCollection args;
ve_init(&e);
e.action = 1;
e.target = &object->base;
e.index = 2;
vec_init(&args);
vec_push(&args, &e);
svr_preGet(settings, &args);
if (!e.handled)
{
gxValueEventArg e2;
ve_init(&e2);
row = (variantArray*)gxmalloc(sizeof(variantArray));
va_init(row);
for (pos = 0; pos != object->captureObjects.size; ++pos)
{
ret = arr_getByIndex(&object->captureObjects, pos, (void**)&kv);
if (ret != DLMS_ERROR_CODE_OK)
{
return ret;
}
e2.target = (gxObject*)kv->key;
e2.index = ((gxTarget*)kv->value)->attributeIndex;
if ((ret = cosem_getData(&e2)) != 0)
{
return ret;
}
value = (dlmsVARIANT*)gxmalloc(sizeof(dlmsVARIANT));
var_init(value);
var_copy(value, &e.value);
va_push(row, value);
}
// Remove first item if buffer is full.
if (object->profileEntries == object->buffer.size)
{
variantArray* removedRow;
arr_removeByIndex(&object->buffer, 0, (void**)&removedRow);
va_clear(removedRow);
}
arr_push(&object->buffer, row);
object->entriesInUse = object->buffer.size;
}
svr_postGet(settings, &args);
vec_empty(&args);
#endif //DLMS_IGNORE_MALLOC
return 0;
}
int invoke_ProfileGeneric(
dlmsServerSettings* settings,
gxProfileGeneric* object,
unsigned char index)
{
int ret = 0;
//Reset.
if (index == 1)
{
#ifndef DLMS_IGNORE_MALLOC
ret = obj_clearProfileGenericBuffer(&object->buffer);
#endif //DLMS_IGNORE_MALLOC
}
//Capture.
else if (index == 2)
{
// Capture.
ret = capture(&settings->base, object);
}
else
{
ret = DLMS_ERROR_CODE_INVALID_PARAMETER;
}
return ret;
}
#endif //DLMS_IGNORE_PROFILE_GENERIC
#ifndef DLMS_IGNORE_COMPACT_DATA
int compactDataAppend(unsigned char byteArray, dlmsVARIANT* value3, gxByteBuffer* bb)
{
if (byteArray && value3->vt == DLMS_DATA_TYPE_OCTET_STRING)
{
if (bb_size(value3->byteArr) == 1)
{
bb_setUInt8(bb, 0);
}
else
{
bb_set(bb, value3->byteArr->data + 1, value3->byteArr->size - 1);
}
return 0;
}
int ret;
uint16_t startPos = (uint16_t)bb->size;
if ((ret = dlms_setData(bb, value3->vt, value3)) != 0)
{
return ret;
}
//If data is empty.
if (bb->size - startPos == 1)
{
bb_setUInt8(bb, 0);
}
else
{
ret = bb_move(bb, startPos + 1, startPos, bb->size - startPos - 1);
}
return 0;
}
int compactDataAppendArray(dlmsVARIANT* value, gxByteBuffer* bb, uint16_t dataIndex)
{
int ret, pos;
int cnt = value->Arr->size;
if (dataIndex != 0)
{
cnt = dataIndex;
--dataIndex;
}
dlmsVARIANT* value2;
for (pos = dataIndex; pos != cnt; ++pos)
{
if ((ret = va_getByIndex(value->Arr, pos, &value2)) != 0)
{
return ret;
}
if (value2->vt == DLMS_DATA_TYPE_STRUCTURE)
{
dlmsVARIANT* value3;
int pos1;
for (pos1 = 0; pos1 != value2->Arr->size; ++pos1)
{
if ((ret = va_getByIndex(value2->Arr, pos1, &value3)) != 0 ||
(ret = compactDataAppend(0, value3, bb)) != 0)
{
return ret;
}
}
}
else
{
if ((ret = compactDataAppend(0, value2, bb)) != 0)
{
return ret;
}
}
}
return 0;
}
/*
* Copies the values of the objects to capture into the buffer by reading
* capture objects.
*/
int cosem_captureCompactData(
dlmsSettings* settings,
gxCompactData* object)
{
int ret = 0;
uint16_t pos;
#ifdef DLMS_IGNORE_MALLOC
gxTarget* kv;
#else
gxKey* kv;
#endif //DLMS_IGNORE_MALLOC
gxValueEventArg e;
gxValueEventCollection args;
bb_clear(&object->buffer);
ve_init(&e);
e.action = 1;
e.target = &object->base;
e.index = 2;
#ifdef DLMS_IGNORE_MALLOC
//Allocate space where captured values are saved before they are added to the buffer.
// We can't use server buffer because there might be transaction on progress when this is called.
unsigned char tmp[MAX_CAPTURE_OBJECT_BUFFER_SIZE];
gxByteBuffer bb;
bb_attach(&bb, tmp, 0, sizeof(tmp));
gxValueEventArg p[1] = { e };
vec_attach(&args, p, 1, 1);
#else
vec_init(&args);
vec_push(&args, &e);
#endif //DLMS_IGNORE_MALLOC
svr_preGet(settings, &args);
if (!e.handled)
{
uint16_t dataIndex;
for (pos = 0; pos != object->captureObjects.size; ++pos)
{
#ifdef DLMS_IGNORE_MALLOC
ret = arr_getByIndex(&object->captureObjects, pos, (void**)&kv, sizeof(gxTarget));
#else
ret = arr_getByIndex(&object->captureObjects, pos, (void**)&kv);
#endif //DLMS_IGNORE_MALLOC
if (ret != DLMS_ERROR_CODE_OK)
{
bb_clear(&object->buffer);
break;
}
#ifdef DLMS_IGNORE_MALLOC
e.value.byteArr = &bb;
e.value.vt = DLMS_DATA_TYPE_OCTET_STRING;
e.target = kv->target;
e.index = kv->attributeIndex;
dataIndex = kv->dataIndex;
#else
e.target = (gxObject*)kv->key;
e.index = ((gxTarget*)kv->value)->attributeIndex;
dataIndex = ((gxTarget*)kv->value)->dataIndex;
#endif //DLMS_IGNORE_MALLOC
if ((ret = cosem_getValue(settings, &e)) != 0)
{
bb_clear(&object->buffer);
break;
}
if (e.byteArray && e.value.vt == DLMS_DATA_TYPE_OCTET_STRING)
{
gxDataInfo info;
dlmsVARIANT value;
di_init(&info);
var_init(&value);
if ((ret = dlms_getData(e.value.byteArr, &info, &value)) != 0)
{
var_clear(&value);
break;
}
if (value.vt == DLMS_DATA_TYPE_STRUCTURE ||
value.vt == DLMS_DATA_TYPE_ARRAY)
{
#ifdef DLMS_ITALIAN_STANDARD
//Some meters require that there is a array count in data.
if (value.vt == DLMS_DATA_TYPE_ARRAY && object->appendAA)
{
bb_setUInt8(&object->buffer, (unsigned char)value.Arr->size);
}
#endif //DLMS_ITALIAN_STANDARD
if ((ret = compactDataAppendArray(&value, &object->buffer, dataIndex)) != 0)
{
var_clear(&value);
break;
}
}
else
{
if ((ret = compactDataAppend(1, &e.value, &object->buffer)) != 0)
{
var_clear(&value);
break;
}
}
var_clear(&value);
}
else if ((ret = compactDataAppend(0, &e.value, &object->buffer)) != 0)
{
break;
}
ve_clear(&e);
}
}
svr_postGet(settings, &args);
if (ret != 0)
{
bb_clear(&object->buffer);
}
vec_empty(&args);
return ret;
}
int invoke_CompactData(
dlmsServerSettings* settings,
gxCompactData* object,
unsigned char index)
{
int ret = 0;
//Reset.
if (index == 1)
{
ret = bb_clear(&object->buffer);
}
//Capture.
else if (index == 2)
{
// Capture.
ret = cosem_captureCompactData(&settings->base, object);
}
else
{
ret = DLMS_ERROR_CODE_INVALID_PARAMETER;
}
return ret;
}
#endif //DLMS_IGNORE_COMPACT_DATA
#ifndef DLMS_IGNORE_DISCONNECT_CONTROL
int invoke_DisconnectControl(
dlmsServerSettings* settings,
gxDisconnectControl* object,
unsigned char index)
{
int ret = 0;
//Reset.
if (index == 1)
{
object->controlState = DLMS_CONTROL_STATE_DISCONNECTED;
object->outputState = 0;
}
//Capture.
else if (index == 2)
{
object->controlState = DLMS_CONTROL_STATE_CONNECTED;
object->outputState = 1;
}
else
{
ret = DLMS_ERROR_CODE_INVALID_PARAMETER;
}
return ret;
}
#endif //DLMS_IGNORE_DISCONNECT_CONTROL
#ifndef DLMS_IGNORE_LLC_SSCS_SETUP
int invoke_LlcSscsSetup(
gxLlcSscsSetup* object,
unsigned char index)
{
int ret = 0;
//Reset.
if (index == 1)
{
object->serviceNodeAddress = 0xFFE;
object->baseNodeAddress = 0;
}
else
{
ret = DLMS_ERROR_CODE_INVALID_PARAMETER;
}
return ret;
}
#endif //DLMS_IGNORE_LLC_SSCS_SETUP
#ifndef DLMS_IGNORE_PRIME_NB_OFDM_PLC_PHYSICAL_LAYER_COUNTERS
int invoke_PrimeNbOfdmPlcPhysicalLayerCounters(
gxPrimeNbOfdmPlcPhysicalLayerCounters* object,
unsigned char index)
{
int ret = 0;
//Reset.
if (index == 1)
{
object->crcIncorrectCount = object->crcFailedCount = object->txDropCount = object->rxDropCount = 0;
}
else
{
ret = DLMS_ERROR_CODE_INVALID_PARAMETER;
}
return ret;
}
#endif //DLMS_IGNORE_PRIME_NB_OFDM_PLC_PHYSICAL_LAYER_COUNTERS
#ifndef DLMS_IGNORE_PRIME_NB_OFDM_PLC_MAC_COUNTERS
int invoke_PrimeNbOfdmPlcMacCounters(
gxPrimeNbOfdmPlcMacCounters* object,
unsigned char index)
{
int ret = 0;
//Reset.
if (index == 1)
{
object->txDataPktCount = object->rxDataPktCount = object->txCtrlPktCount = object->rxCtrlPktCount = object->csmaFailCount = object->csmaChBusyCount = 0;
}
else
{
ret = DLMS_ERROR_CODE_INVALID_PARAMETER;
}
return ret;
}
#endif //DLMS_IGNORE_PRIME_NB_OFDM_PLC_MAC_COUNTERS
#ifndef DLMS_IGNORE_PRIME_NB_OFDM_PLC_MAC_NETWORK_ADMINISTRATION_DATA
int invoke_PrimeNbOfdmPlcMacNetworkAdministrationData(
gxPrimeNbOfdmPlcMacNetworkAdministrationData* object,
unsigned char index)
{
int ret = 0;
//Reset.
if (index == 1)
{
arr_clear(&object->multicastEntries);
arr_empty(&object->switchTable);
arr_clear(&object->directTable);
obj_clearAvailableSwitches(&object->availableSwitches);
arr_clear(&object->communications);
}
else
{
ret = DLMS_ERROR_CODE_INVALID_PARAMETER;
}
return ret;
}
#endif //DLMS_IGNORE_PRIME_NB_OFDM_PLC_MAC_NETWORK_ADMINISTRATION_DATA
#ifndef DLMS_IGNORE_SPECIAL_DAYS_TABLE
int invoke_SpecialDaysTable(
gxSpecialDaysTable* object,
gxValueEventArg* e)
{
int ret = 0;
uint16_t pos, index;
gxSpecialDay* specialDay;
//Insert.
if (e->index == 1)
{
unsigned char append = 1;
#ifdef DLMS_IGNORE_MALLOC
if ((ret = cosem_checkStructure(e->parameters.byteArr, 3)) == 0 &&
(ret = cosem_getUInt16(e->parameters.byteArr, &index)) == 0)
{
for (pos = 0; pos != object->entries.size; ++pos)
{
if ((ret = arr_getByIndex(&object->entries, object->entries.size - 1, (void**)&specialDay, sizeof(gxSpecialDay))) != 0)
{
break;
}
//Overwrite existing item.
if (specialDay->index == index)
{
if ((ret = cosem_getDateFromOctetString(e->parameters.byteArr, &specialDay->date)) != 0 ||
(ret = cosem_getUInt8(e->parameters.byteArr, &specialDay->dayId)) != 0)
{
}
append = 0;
break;
}
}
if (ret == 0 && append)
{
++object->entries.size;
if ((ret = arr_getByIndex(&object->entries, object->entries.size - 1, (void**)&specialDay, sizeof(gxSpecialDay))) != 0)
{
--object->entries.size;
}
else
{
specialDay->index = index;
if ((ret = cosem_getDateFromOctetString(e->parameters.byteArr, &specialDay->date)) != 0 ||
(ret = cosem_getUInt8(e->parameters.byteArr, &specialDay->dayId)) != 0)
{
}
}
}
}
#else
dlmsVARIANT* tmp3;
dlmsVARIANT tmp2;
if (e->parameters.Arr != NULL)
{
ret = va_getByIndex(e->parameters.Arr, 0, &tmp3);
if (ret != DLMS_ERROR_CODE_OK)
{
return ret;
}
index = (uint16_t)var_toInteger(tmp3);
for (pos = 0; pos != object->entries.size; ++pos)
{
if ((ret = arr_getByIndex(&object->entries, object->entries.size - 1, (void**)&specialDay)) != 0)
{
break;
}
//Overwrite existing item.
if (specialDay->index == index)
{
append = 0;
break;
}
}
if (append)
{
specialDay = (gxSpecialDay*)gxmalloc(sizeof(gxSpecialDay));
if (specialDay == NULL)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
arr_push(&object->entries, specialDay);
}
specialDay->index = index;
ret = va_getByIndex(e->parameters.Arr, 1, &tmp3);
if (ret != DLMS_ERROR_CODE_OK)
{
return ret;
}
var_init(&tmp2);
ret = dlms_changeType2(tmp3, DLMS_DATA_TYPE_DATE, &tmp2);
if (ret != DLMS_ERROR_CODE_OK)
{
return ret;
}
time_copy(&specialDay->date, tmp2.dateTime);
var_clear(&tmp2);
ret = va_getByIndex(e->parameters.Arr, 2, &tmp3);
if (ret != DLMS_ERROR_CODE_OK)
{
return ret;
}
specialDay->dayId = (unsigned char)var_toInteger(tmp3);
}
#endif //DLMS_IGNORE_MALLOC
}
//Remove.
else if (e->index == 2)
{
uint16_t pos, index = e->parameters.uiVal;
for (pos = 0; pos != object->entries.size; ++pos)
{
#ifdef DLMS_IGNORE_MALLOC
if ((ret = arr_getByIndex(&object->entries, pos, (void**)&specialDay, sizeof(gxSpecialDay))) != 0)
#else
if ((ret = arr_getByIndex(&object->entries, pos, (void**)&specialDay)) != 0)
#endif //DLMS_IGNORE_MALLOC
{
break;
}
if (specialDay->index == index)
{
//Remove item.
#ifdef DLMS_IGNORE_MALLOC
ret = arr_removeByIndex(&object->entries, pos, sizeof(gxSpecialDay));
#else
ret = arr_removeByIndex(&object->entries, pos, NULL);
#endif //DLMS_IGNORE_MALLOC
break;
}
}
}
else
{
ret = DLMS_ERROR_CODE_INVALID_PARAMETER;
}
return ret;
}
#endif //DLMS_IGNORE_SPECIAL_DAYS_TABLE
#ifndef DLMS_IGNORE_REGISTER_ACTIVATION
int invoke_RegisterActivation(
dlmsServerSettings* settings,
gxRegisterActivation* object,
gxValueEventArg* e)
{
int ret = 0;
uint16_t count;
gxRegisterActivationMask* k;
uint16_t pos;
#ifdef DLMS_IGNORE_OBJECT_POINTERS
gxObjectDefinition* it;
#else
gxObject* it;
#endif //DLMS_IGNORE_OBJECT_POINTERS
//Add Register.
if (e->index == 1)
{
#ifdef DLMS_IGNORE_MALLOC
uint16_t ot;
unsigned char ln[6];
#if !(defined(DLMS_IGNORE_OBJECT_POINTERS) || defined(DLMS_IGNORE_MALLOC))
uint16_t count = oa_getCapacity(&object->registerAssignment);
#else
count = arr_getCapacity(&object->registerAssignment);
if (!(object->registerAssignment.size < count))
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
#endif //!(defined(DLMS_IGNORE_OBJECT_POINTERS) || defined(DLMS_IGNORE_MALLOC))
if ((ret = cosem_checkStructure(e->parameters.byteArr, 2)) != 0 ||
#ifndef DLMS_IGNORE_OBJECT_POINTERS
(ret = cosem_getUInt16(e->parameters.byteArr, &ot)) != 0 ||
(ret = cosem_getOctetString2(e->parameters.byteArr, ln, 6, NULL)) != 0)
{
return ret;
}
if ((ret = oa_findByLN(&settings->base.objects, (DLMS_OBJECT_TYPE)ot, ln, &it)) != 0)
{
return ret;
}
if (it == NULL)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
if ((ret = arr_setByIndexRef(&object->registerAssignment, (void**)it)) != 0)
{
return ret;
}
#endif //DLMS_IGNORE_OBJECT_POINTERS
#else
dlmsVARIANT* tmp, * tmp3;
if (e->parameters.Arr != NULL)
{
short type;
ret = va_getByIndex(e->parameters.Arr, 0, &tmp);
if (ret != DLMS_ERROR_CODE_OK)
{
return ret;
}
ret = va_getByIndex(tmp->Arr, 0, &tmp3);
if (ret != DLMS_ERROR_CODE_OK)
{
return ret;
}
type = var_toInteger(tmp3);
ret = va_getByIndex(tmp->Arr, 1, &tmp3);
if (ret != DLMS_ERROR_CODE_OK)
{
return ret;
}
const unsigned char* ln = tmp3->byteArr->data;
#ifdef DLMS_IGNORE_OBJECT_POINTERS
it = (gxObjectDefinition*)gxmalloc(sizeof(gxObjectDefinition));
it->objectType = (DLMS_OBJECT_TYPE)type;
memcpy(it->logicalName, ln, 6);
#else
if ((ret = oa_findByLN(&settings->base.objects, type, ln, &it)) != 0)
{
return ret;
}
if (it == NULL)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
#endif //DLMS_IGNORE_OBJECT_POINTERS
#if !defined(DLMS_IGNORE_OBJECT_POINTERS) && !defined(DLMS_COSEM_EXACT_DATA_TYPES)
oa_push(&object->registerAssignment, it);
#else
arr_push(&object->registerAssignment, it);
#endif //DLMS_IGNORE_OBJECT_POINTERS
}
#ifdef DLMS_IGNORE_OBJECT_POINTERS
if (ret != 0 && objectDefinition != NULL)
{
gxfree(objectDefinition);
}
#endif //DLMS_IGNORE_OBJECT_POINTERS
#endif //DLMS_IGNORE_MALLOC
}
else if (e->index == 2)
{
count = arr_getCapacity(&object->maskList);
if (!(object->registerAssignment.size < count))
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
++object->maskList.size;
#ifdef DLMS_IGNORE_MALLOC
uint16_t size;
if ((ret = cosem_checkStructure(e->parameters.byteArr, 2)) == 0 &&
(ret = arr_getByIndex(&object->maskList, object->maskList.size - 1, (void**)&k, sizeof(gxRegisterActivationMask))) == 0 &&
(ret = cosem_getOctetString2(e->parameters.byteArr, k->name, sizeof(k->name), &size)) == 0)
{
k->length = (unsigned char)size;
size = sizeof(k->indexes);
if ((ret = cosem_checkArray(e->parameters.byteArr, &size)) == 0)
{
k->count = (unsigned char)size;
for (pos = 0; pos != k->count; ++pos)
{
if ((ret = cosem_getUInt8(e->parameters.byteArr, &k->indexes[pos])) != 0)
{
break;
}
}
}
}
#else
#endif //DLMS_IGNORE_OBJECT_POINTERS
}
//Remove mask.
else if (e->index == 3)
{
unsigned char ch;
if ((ret = bb_getUInt8(e->parameters.byteArr, &ch)) == 0)
{
if (ch != DLMS_DATA_TYPE_OCTET_STRING)
{
ret = DLMS_ERROR_CODE_INVALID_PARAMETER;
}
else
{
uint16_t count;
if ((ret = hlp_getObjectCount2(e->parameters.byteArr, &count)) == 0)
{
for (pos = 0; pos != object->maskList.size; ++pos)
{
if ((ret = arr_getByIndex2(&object->maskList, pos, (void**)&k, sizeof(gxRegisterActivationMask))) != 0)
{
break;
}
#if defined(DLMS_IGNORE_MALLOC)
if (bb_available(e->parameters.byteArr) == k->length &&
memcmp(k->name, e->parameters.byteArr->data + e->parameters.byteArr->position, count) == 0)
{
//arr_removeByIndex is decreasing amount already.
ret = arr_removeByIndex(&object->maskList, pos, sizeof(gxRegisterActivationMask));
break;
}
#else
if (bb_available(e->parameters.byteArr) == k->name.size &&
memcmp(k->name.data, e->parameters.byteArr->data + e->parameters.byteArr->position, count) == 0)
{
//arr_removeByIndex is decreasing amount already.
if ((ret = arr_removeByIndex(&object->maskList, pos, (void**)&k)) == 0)
{
bb_clear(&k->name);
bb_clear(&k->indexes);
gxfree(k);
}
break;
}
#endif //defined(DLMS_IGNORE_MALLOC)
e->parameters.byteArr->position += count;
}
}
}
}
bb_clear(e->parameters.byteArr);
}
else
{
ret = DLMS_ERROR_CODE_INVALID_PARAMETER;
}
return ret;
}
#endif //DLMS_IGNORE_REGISTER_ACTIVATION
#ifndef DLMS_IGNORE_ACTIVITY_CALENDAR
int invoke_copySeasonProfile(gxArray* target, gxArray* source)
{
int ret = obj_clearSeasonProfile(target);
if (ret == 0)
{
int pos;
gxSeasonProfile* sp, * it;
#if defined(DLMS_IGNORE_MALLOC)
target->size = source->size;
#endif //
for (pos = 0; pos != source->size; ++pos)
{
if (ret == 0)
{
if ((ret = arr_getByIndex2(source, pos, (void**)&sp, sizeof(gxSeasonProfile))) != 0)
{
break;
}
#if defined(DLMS_IGNORE_MALLOC)
if ((ret = arr_getByIndex2(target, pos, (void**)&it, sizeof(gxSeasonProfile))) != 0)
{
break;
}
memcpy(&it->name, &sp->name, sizeof(gxSeasonProfileName));
it->start = sp->start;
memcpy(&it->weekName, &sp->weekName, sizeof(gxSeasonProfileWeekName));
#else
it = gxmalloc(sizeof(gxSeasonProfile));
arr_push(target, it);
BYTE_BUFFER_INIT(&it->name);
BYTE_BUFFER_INIT(&it->weekName);
bb_set(&it->name, sp->name.data, sp->name.size);
it->start = sp->start;
bb_set(&it->weekName, sp->weekName.data, sp->weekName.size);
#endif //#if defined(DLMS_IGNORE_MALLOC)
}
}
}
return ret;
}
int invoke_copyWeekProfileTable(gxArray* target, gxArray* source)
{
int ret = obj_clearWeekProfileTable(target);
if (ret == 0)
{
int pos;
gxWeekProfile* wp, * it;
#if defined(DLMS_IGNORE_MALLOC)
target->size = source->size;
#endif //
for (pos = 0; pos != source->size; ++pos)
{
if (ret == 0)
{
if ((ret = arr_getByIndex2(source, pos, (void**)&wp, sizeof(gxWeekProfile))) != 0)
{
break;
}
#if defined(DLMS_IGNORE_MALLOC)
if ((ret = arr_getByIndex2(target, pos, (void**)&it, sizeof(gxWeekProfile))) != 0)
{
break;
}
memcpy(&it->name, &wp->name, sizeof(gxWeekProfileName));
#else
it = gxmalloc(sizeof(gxWeekProfile));
arr_push(target, it);
BYTE_BUFFER_INIT(&it->name);
bb_set(&it->name, wp->name.data, wp->name.size);
#endif //#if defined(DLMS_IGNORE_MALLOC)
it->monday = wp->monday;
it->tuesday = wp->tuesday;
it->wednesday = wp->wednesday;
it->thursday = wp->thursday;
it->friday = wp->friday;
it->saturday = wp->saturday;
it->sunday = wp->sunday;
}
}
}
return ret;
}
int invoke_copyDayProfileTable(gxArray* target, gxArray* source)
{
int ret = obj_clearDayProfileTable(target);
if (ret == 0)
{
int pos, pos2;
gxDayProfile* it, * it2;
gxDayProfileAction* dp, * dp2;
#if defined(DLMS_IGNORE_MALLOC)
target->size = source->size;
#endif //
for (pos = 0; pos != source->size; ++pos)
{
if (ret == 0)
{
if ((ret = arr_getByIndex2(source, pos, (void**)&it, sizeof(gxDayProfile))) != 0)
{
break;
}
#if defined(DLMS_IGNORE_MALLOC)
if ((ret = arr_getByIndex2(target, pos, (void**)&it2, sizeof(gxDayProfile))) != 0)
{
break;
}
it2->daySchedules.size = it->daySchedules.size;
#else
it2 = gxmalloc(sizeof(gxDayProfile));
arr_push(target, it);
#endif //#if defined(DLMS_IGNORE_MALLOC)
it2->dayId = it->dayId;
for (pos2 = 0; pos2 != it->daySchedules.size; ++pos2)
{
if ((ret = arr_getByIndex2(&it->daySchedules, pos2, (void**)&dp, sizeof(gxDayProfileAction))) != DLMS_ERROR_CODE_OK)
{
break;
}
#if defined(DLMS_IGNORE_MALLOC)
if ((ret = arr_getByIndex2(&it2->daySchedules, pos2, (void**)&dp2, sizeof(gxDayProfileAction))) != DLMS_ERROR_CODE_OK)
{
break;
}
#else
dp2 = gxmalloc(sizeof(gxDayProfileAction));
arr_push(&it2->daySchedules, dp2);
#endif //#if defined(DLMS_IGNORE_MALLOC)
dp2->startTime = dp->startTime;
#ifndef DLMS_IGNORE_OBJECT_POINTERS
dp2->script = dp->script;
#else
memcpy(dp2->scriptLogicalName, dp->scriptLogicalName, 6);
#endif //DLMS_IGNORE_OBJECT_POINTERS
dp2->scriptSelector = dp->scriptSelector;
}
}
}
}
return ret;
}
int invoke_ActivityCalendar(gxValueEventArg* e)
{
int ret;
if (e->index == 1)
{
//Copy all passive items to active.
gxActivityCalendar* object = (gxActivityCalendar*)e->target;
bb_clear(&object->calendarNameActive);
if ((ret = bb_set(&object->calendarNameActive, object->calendarNamePassive.data, object->calendarNamePassive.size)) != 0 ||
(ret = invoke_copyDayProfileTable(&object->dayProfileTableActive, &object->dayProfileTablePassive)) != 0 ||
(ret = invoke_copyWeekProfileTable(&object->weekProfileTableActive, &object->weekProfileTablePassive)) != 0 ||
(ret = invoke_copySeasonProfile(&object->seasonProfileActive, &object->seasonProfilePassive)) != 0)
{
}
}
else
{
ret = DLMS_ERROR_CODE_INVALID_PARAMETER;
}
return ret;
}
#endif //DLMS_IGNORE_ACTIVITY_CALENDAR
#ifndef DLMS_IGNORE_ARRAY_MANAGER
int invoke_ArrayManagerInsertEntry(
dlmsServerSettings* settings,
gxValueEventArg* e, uint16_t index)
{
int ret;
uint16_t count, pos, totalCount;
uint16_t origPos = 0;
unsigned char ch;
dlmsVARIANT value;
gxDataInfo info;
di_init(&info);
var_init(&value);
//Move new data to the begin of the buffer.
ret = bb_move(e->value.byteArr, e->value.byteArr->position, 0, bb_available(e->value.byteArr));
uint16_t newDataSize = (uint16_t)e->value.byteArr->size;
if ((ret = cosem_getValue(&settings->base, e)) == 0 && bb_size(e->value.byteArr) != 0)
{
if ((ret = bb_getUInt8(e->value.byteArr, &ch)) != 0 ||
ch != DLMS_DATA_TYPE_ARRAY)
{
return DLMS_ERROR_CODE_INVALID_PARAMETER;
}
if ((ret = hlp_getObjectCount2(e->value.byteArr, &totalCount)) != 0)
{
return ret;
}
//Change index to zero-based.
count = (uint16_t)e->value.byteArr->size;
e->value.byteArr->size = newDataSize + 1;
if ((ret = hlp_setObjectCount(1 + totalCount, e->value.byteArr)) != 0)
{
return ret;
}
totalCount = 0;
//Return original size.
e->value.byteArr->size = count;
for (pos = (uint16_t)e->value.byteArr->position; pos != bb_size(e->value.byteArr); ++pos)
{
//Get data type.
if ((ret = bb_getUInt8ByIndex(e->value.byteArr, e->value.byteArr->position, &ch)) != 0)
{
break;
}
if (ch == DLMS_DATA_TYPE_ARRAY || ch == DLMS_DATA_TYPE_STRUCTURE)
{
if (index == 0)
{
//Save start position.
origPos = (uint16_t)e->value.byteArr->position;
}
++e->value.byteArr->position;
if ((ret = hlp_getObjectCount2(e->value.byteArr, &count)) != 0)
{
break;
}
totalCount += 1 + count;
}
else
{
if ((ret = dlms_getData(e->value.byteArr, &info, &value)) != 0)
{
var_clear(&value);
break;
}
#ifdef DLMS_IGNORE_MALLOC
if (value.vt == DLMS_DATA_TYPE_OCTET_STRING)
{
++e->value.byteArr->position;
if ((ret = hlp_getObjectCount2(e->value.byteArr, &count)) != 0)
{
var_clear(&value);
break;
}
if (e->value.byteArr->size < e->value.byteArr->position + count)
{
ret = DLMS_ERROR_CODE_OUTOFMEMORY;
var_clear(&value);
break;
}
e->value.byteArr->position += count;
}
#endif //DLMS_IGNORE_MALLOC
di_init(&info);
var_clear(&value);
}
--totalCount;
if (index == 0 && totalCount == 0)
{
if (bb_available(e->value.byteArr) == 0)
{
//Move first item to last.
ret = bb_move(e->value.byteArr, 0, e->value.byteArr->size, newDataSize);
//Move all items to begin.
ret = bb_move(e->value.byteArr, newDataSize, 0, e->value.byteArr->size - newDataSize);
e->value.byteArr->position = 0;
ret = cosem_setValue(&settings->base, e);
bb_clear(e->value.byteArr);
break;
}
else if (index == 0)
{
//Make space for the new item.
ret = bb_move(e->value.byteArr, origPos,
origPos + newDataSize, e->value.byteArr->size - newDataSize);
//Move new item to new location.
totalCount = (uint16_t)e->value.byteArr->size;
ret = bb_move(e->value.byteArr, 0, origPos, newDataSize);
e->value.byteArr->size = totalCount;
//Move all items to first.
ret = bb_move(e->value.byteArr, newDataSize, 0, e->value.byteArr->size - newDataSize);
e->value.byteArr->position = 0;
#ifdef DLMS_IGNORE_MALLOC
ret = cosem_setValue(&settings->base, e);
bb_clear(e->value.byteArr);
#else
gxByteBuffer* bb = e->value.byteArr;
e->value.vt = DLMS_DATA_TYPE_NONE;
if ((ret = dlms_getData(e->value.byteArr, &info, &e->value)))
{
bb_clear(bb);
var_clear(&value);
break;
}
bb_clear(bb);
if ((ret = cosem_setValue(&settings->base, e)) != 0)
{
var_clear(&value);
break;
}
#endif //DLMS_IGNORE_MALLOC
break;
}
--index;
}
}
}
return ret;
}
int invoke_ArrayManagerDeleteEntry(
dlmsServerSettings* settings,
gxValueEventArg* e,
uint16_t from, uint16_t to)
{
int ret;
uint16_t count, pos, totalCount;
uint16_t origPos = 0;
unsigned char ch;
dlmsVARIANT value;
gxDataInfo info;
di_init(&info);
var_init(&value);
if ((ret = cosem_getValue(&settings->base, e)) == 0 && bb_size(e->value.byteArr) != 0)
{
if ((ret = bb_getUInt8(e->value.byteArr, &ch)) != 0 ||
ch != DLMS_DATA_TYPE_ARRAY)
{
return DLMS_ERROR_CODE_INVALID_PARAMETER;
}
if ((ret = hlp_getObjectCount2(e->value.byteArr, &totalCount)) != 0)
{
return ret;
}
//Change from to zero-based.
--from;
if (to - from < totalCount)
{
totalCount -= to - from;
}
else
{
totalCount = from;
to = from + 1;
}
count = (uint16_t)e->value.byteArr->size;
e->value.byteArr->size = 1;
if ((ret = hlp_setObjectCount(totalCount, e->value.byteArr)) != 0)
{
return ret;
}
totalCount = 0;
//Return original size.
e->value.byteArr->size = count;
for (pos = (uint16_t)e->value.byteArr->position; pos != bb_size(e->value.byteArr); ++pos)
{
//Get data type.
if ((ret = bb_getUInt8ByIndex(e->value.byteArr, e->value.byteArr->position, &ch)) != 0)
{
break;
}
if (ch == DLMS_DATA_TYPE_ARRAY || ch == DLMS_DATA_TYPE_STRUCTURE)
{
if (from == 0)
{
//Save start position.
origPos = (uint16_t)e->value.byteArr->position;
}
++e->value.byteArr->position;
if ((ret = hlp_getObjectCount2(e->value.byteArr, &count)) != 0)
{
break;
}
totalCount += 1 + count;
}
else
{
if ((ret = dlms_getData(e->value.byteArr, &info, &value)) != 0)
{
var_clear(&value);
break;
}
#ifdef DLMS_IGNORE_MALLOC
if (value.vt == DLMS_DATA_TYPE_OCTET_STRING)
{
++e->value.byteArr->position;
if ((ret = hlp_getObjectCount2(e->value.byteArr, &count)) != 0)
{
break;
}
if (e->value.byteArr->size < e->value.byteArr->position + count)
{
ret = DLMS_ERROR_CODE_OUTOFMEMORY;
break;
}
e->value.byteArr->position += count;
}
#endif //DLMS_IGNORE_MALLOC
di_init(&info);
var_clear(&value);
}
--totalCount;
if (totalCount == 0)
{
--to;
if (to == 0)
{
ret = bb_move(e->value.byteArr, e->value.byteArr->position, origPos,
bb_available(e->value.byteArr));
e->value.byteArr->position = 0;
ret = cosem_setValue(&settings->base, e);
bb_clear(e->value.byteArr);
break;
}
--from;
}
}
}
return ret;
}
int invoke_ArrayManager(
dlmsServerSettings* settings,
gxValueEventArg* e)
{
int pos, ret = 0;
gxArrayManagerItem* it;
gxArrayManager* object = (gxArrayManager*)e->target;
unsigned char ch, found = 0;
uint16_t count, totalCount;
dlmsVARIANT tmp;
dlmsVARIANT value;
gxDataInfo info;
#ifndef DLMS_IGNORE_MALLOC
dlmsVARIANT* tmp2, * tmp3;
e->value.byteArr = &settings->info.data;
#endif//DLMS_IGNORE_MALLOC
e->byteArray = 1;
unsigned char id;
uint16_t index = 0, from = 0, to = 0, origSize, origPos = 0;
if (e->index == 1)
{
id = e->parameters.bVal;
bb_clear(e->value.byteArr);
}
else if (e->index == 3 || e->index == 4)
{
//Insert or update entry.
#ifdef DLMS_IGNORE_MALLOC
if ((ret = cosem_getStructure(e->parameters.byteArr, &count)) != 0 ||
(ret = cosem_getUInt8(e->parameters.byteArr, &id)) != 0 ||
(ret = cosem_getStructure(e->parameters.byteArr, &count)) != 0 ||
(ret = cosem_getUInt16(e->parameters.byteArr, &index)) != 0)
{
return ret;
}
#else
if ((ret = va_getByIndex(e->parameters.Arr, 0, &tmp2)) != 0)
{
return ret;
}
id = tmp2->bVal;
if ((ret = va_getByIndex(e->parameters.Arr, 1, &tmp3)) != 0)
{
return ret;
}
if ((ret = va_getByIndex(tmp3->Arr, 0, &tmp2)) != 0)
{
return ret;
}
from = tmp2->uiVal;
if ((ret = va_getByIndex(tmp3->Arr, 1, &tmp2)) != 0)
{
return ret;
}
to = tmp2->uiVal;
#endif //DLMS_IGNORE_MALLOC
}
else
{
#ifdef DLMS_IGNORE_MALLOC
if ((ret = cosem_getStructure(e->parameters.byteArr, &count)) != 0 ||
(ret = cosem_getUInt8(e->parameters.byteArr, &id)) != 0 ||
(ret = cosem_getStructure(e->parameters.byteArr, &count)) != 0 ||
(ret = cosem_getUInt16(e->parameters.byteArr, &from)) != 0 ||
(ret = cosem_getUInt16(e->parameters.byteArr, &to)) != 0)
{
return ret;
}
#else
if ((ret = va_getByIndex(e->parameters.Arr, 0, &tmp2)) != 0)
{
return ret;
}
id = tmp2->bVal;
if ((ret = va_getByIndex(e->parameters.Arr, 1, &tmp3)) != 0)
{
return ret;
}
if ((ret = va_getByIndex(tmp3->Arr, 0, &tmp2)) != 0)
{
return ret;
}
from = tmp2->uiVal;
if ((ret = va_getByIndex(tmp3->Arr, 1, &tmp2)) != 0)
{
return ret;
}
to = tmp2->uiVal;
#endif //DLMS_IGNORE_MALLOC
bb_clear(e->value.byteArr);
}
for (pos = 0; pos != object->elements.size; ++pos)
{
#ifdef DLMS_IGNORE_MALLOC
ret = arr_getByIndex(&object->elements, pos, (void**)&it, sizeof(gxArrayManagerItem));
#else
ret = arr_getByIndex(&object->elements, pos, (void**)&it);
#endif //DLMS_IGNORE_MALLOC
if (ret != 0)
{
break;
}
if (it->id == id)
{
if (e->index == 1)
{
//Number Of Entries.
if (it->element.target->objectType == DLMS_OBJECT_TYPE_PROFILE_GENERIC
&& it->element.attributeIndex == 2)
{
//Entries in use is returned when buffer size is asked.
GX_UINT32(tmp) = ((gxProfileGeneric*)it->element.target)->entriesInUse;
}
else
{
e->index = it->element.attributeIndex;
e->target = it->element.target;
if ((ret = cosem_getValue(&settings->base, e)) != 0 ||
(ret = bb_getUInt8(e->value.byteArr, &ch)) != 0)
{
break;
}
if (ch != DLMS_DATA_TYPE_ARRAY)
{
ret = DLMS_ERROR_CODE_READ_WRITE_DENIED;
break;
}
if (hlp_getObjectCount2(e->value.byteArr, &count) != 0)
{
break;
}
if (count < 0x100)
{
GX_UINT8(tmp) = (unsigned char)count;
}
else
{
GX_UINT16(tmp) = count;
}
}
bb_clear(e->value.byteArr);
if ((ret = dlms_setData(e->value.byteArr, tmp.vt, &tmp)) != 0)
{
break;
}
found = 1;
break;
}
else if (e->index == 2)
{
//Retrieve entries.
if (it->element.target->objectType == DLMS_OBJECT_TYPE_PROFILE_GENERIC)
{
}
if (!found)
{
di_init(&info);
var_init(&value);
e->index = it->element.attributeIndex;
e->target = it->element.target;
if ((ret = cosem_getValue(&settings->base, e)) == 0 && bb_size(e->value.byteArr) != 0)
{
if ((ret = bb_getUInt8(e->value.byteArr, &ch)) != 0 ||
ch != DLMS_DATA_TYPE_ARRAY)
{
break;
}
if ((ret = hlp_getObjectCount2(e->value.byteArr, &totalCount)) != 0)
{
break;
}
//Change from to zero-based.
--from;
if (to - from < totalCount)
{
totalCount = to - from;
}
else if (totalCount < to)
{
if (totalCount == 0)
{
to = 1;
}
else
{
to = totalCount;
}
}
count = (uint16_t)e->value.byteArr->size;
e->value.byteArr->size = 1;
if ((ret = hlp_setObjectCount(totalCount, e->value.byteArr)) != 0)
{
break;
}
totalCount = 0;
origSize = (uint16_t)e->value.byteArr->size;
//Return original size.
e->value.byteArr->size = count;
for (pos = e->value.byteArr->position; pos != bb_size(e->value.byteArr); ++pos)
{
//Get data type.
if ((ret = bb_getUInt8ByIndex(e->value.byteArr, e->value.byteArr->position, &ch)) != 0)
{
break;
}
if (ch == DLMS_DATA_TYPE_ARRAY || ch == DLMS_DATA_TYPE_STRUCTURE)
{
if (from == 0)
{
//Save start position.
origPos = (uint16_t)e->value.byteArr->position;
}
++e->value.byteArr->position;
if ((ret = hlp_getObjectCount2(e->value.byteArr, &count)) != 0)
{
break;
}
totalCount += 1 + count;
}
else
{
if ((ret = dlms_getData(e->value.byteArr, &info, &value)) != 0)
{
var_clear(&value);
break;
}
#ifdef DLMS_IGNORE_MALLOC
if (value.vt == DLMS_DATA_TYPE_OCTET_STRING)
{
++e->value.byteArr->position;
if ((ret = hlp_getObjectCount2(e->value.byteArr, &count)) != 0)
{
break;
}
if (e->value.byteArr->size < e->value.byteArr->position + count)
{
ret = DLMS_ERROR_CODE_OUTOFMEMORY;
break;
}
e->value.byteArr->position += count;
}
#endif //DLMS_IGNORE_MALLOC
di_init(&info);
var_clear(&value);
}
--totalCount;
if (totalCount == 0)
{
--to;
if (to == 0)
{
ret = bb_move(e->value.byteArr, origPos,
origSize, e->value.byteArr->position - origPos);
e->value.byteArr->position = 0;
break;
}
--from;
}
}
found = 1;
break;
}
}
break;
}
else if (e->index == 3)
{
e->index = it->element.attributeIndex;
e->target = it->element.target;
ret = invoke_ArrayManagerInsertEntry(settings, e, index);
found = 1;
break;
}
else if (e->index == 4)
{
e->index = it->element.attributeIndex;
e->target = it->element.target;
ret = invoke_ArrayManagerDeleteEntry(settings, e, index, index);
ret = invoke_ArrayManagerInsertEntry(settings, e, index);
found = 1;
break;
}
else if (e->index == 5)
{
e->index = it->element.attributeIndex;
e->target = it->element.target;
ret = invoke_ArrayManagerDeleteEntry(settings, e, from, to);
found = 1;
break;
}
}
}
if (!found)
{
bb_clear(e->value.byteArr);
ret = DLMS_ERROR_CODE_READ_WRITE_DENIED;
}
return ret;
}
#endif //DLMS_IGNORE_ARRAY_MANAGER
#ifndef DLMS_IGNORE_G3_PLC_MAC_SETUP
int invoke_G3_PLC_MAC_Setup(
dlmsServerSettings* settings,
gxG3PlcMacSetup* object,
gxValueEventArg* e)
{
uint16_t address, pos, count = 0;
int ret = 0;
e->byteArray = 1;
bb_clear(&settings->info.data);
e->value.byteArr = &settings->info.data;
if (e->parameters.vt != DLMS_DATA_TYPE_UINT16)
{
return DLMS_ERROR_CODE_INVALID_PARAMETER;
}
address = e->parameters.uiVal;
if (e->index == 1)
{
//Get amount of neighbour tables.
gxNeighbourTable* it;
for (pos = 0; pos < (uint16_t)object->neighbourTable.size; ++pos)
{
#ifndef DLMS_IGNORE_MALLOC
if ((ret = arr_getByIndex(&object->neighbourTable, pos, (void**)&it)) != 0)
{
break;
}
#else
if ((ret = arr_getByIndex(&object->neighbourTable, pos,
(void**)&it, sizeof(gxNeighbourTable))) != 0)
{
break;
}
#endif //DLMS_IGNORE_MALLOC
if (it->shortAddress == address)
{
++count;
}
}
if (ret == 0)
{
return cosem_getG3PlcMacSetupNeighbourTables(&object->neighbourTable, address, count, e);
}
}
else if (e->index == 2)
{
gxMacPosTable* it;
//Get amount of MAC POS tables.
for (pos = 0; pos < object->macPosTable.size; ++pos)
{
#ifndef DLMS_IGNORE_MALLOC
if ((ret = arr_getByIndex(&object->macPosTable, pos, (void**)&it)) != 0)
{
break;
}
#else
if ((ret = arr_getByIndex(&object->macPosTable, pos, (void**)&it, sizeof(gxMacPosTable))) != 0)
{
break;
}
#endif //DLMS_IGNORE_MALLOC
if (it->shortAddress == address)
{
++count;
}
}
if (ret == 0)
{
return cosem_getG3PlcMacSetupPosTables(&object->macPosTable, address, count, e);
}
}
bb_clear(e->value.byteArr);
return DLMS_ERROR_CODE_READ_WRITE_DENIED;
}
#endif //DLMS_IGNORE_G3_PLC_MAC_SETUP
int cosem_invoke(
dlmsServerSettings* settings,
gxValueEventArg* e)
{
int ret = DLMS_ERROR_CODE_INVALID_PARAMETER;
//If invoke index is invalid.
if (e->index < 1 || e->index > obj_methodCount(e->target))
{
return DLMS_ERROR_CODE_INVALID_PARAMETER;
}
switch (e->target->objectType)
{
#ifndef DLMS_IGNORE_REGISTER
case DLMS_OBJECT_TYPE_REGISTER:
ret = invoke_Register(
(gxRegister*)e->target,
e);
break;
#endif //DLMS_IGNORE_REGISTER
#ifndef DLMS_IGNORE_CLOCK
case DLMS_OBJECT_TYPE_CLOCK:
ret = invoke_Clock(
(gxClock*)e->target,
e->index, &e->parameters);
break;
#endif //DLMS_IGNORE_CLOCK
#ifndef DLMS_IGNORE_EXTENDED_REGISTER
case DLMS_OBJECT_TYPE_EXTENDED_REGISTER:
ret = invoke_ExtendedRegister(settings,
(gxExtendedRegister*)e->target,
e->index);
break;
#endif //DLMS_IGNORE_EXTENDED_REGISTER
#ifndef DLMS_IGNORE_DEMAND_REGISTER
case DLMS_OBJECT_TYPE_DEMAND_REGISTER:
ret = invoke_DemandRegister(settings,
(gxDemandRegister*)e->target,
e->index);
break;
#endif //DLMS_IGNORE_DEMAND_REGISTER
#ifndef DLMS_IGNORE_PROFILE_GENERIC
case DLMS_OBJECT_TYPE_PROFILE_GENERIC:
ret = invoke_ProfileGeneric(
settings,
(gxProfileGeneric*)e->target,
e->index);
break;
#endif //DLMS_IGNORE_PROFILE_GENERIC
#ifndef DLMS_IGNORE_SCRIPT_TABLE
case DLMS_OBJECT_TYPE_SCRIPT_TABLE:
ret = invoke_ScriptTable(settings, e);
break;
#endif //DLMS_IGNORE_SCRIPT_TABLE
#ifndef DLMS_IGNORE_ZIG_BEE_NETWORK_CONTROL
case DLMS_OBJECT_TYPE_ZIG_BEE_NETWORK_CONTROL:
ret = invoke_zigbeeNetworkControl(
(gxZigBeeNetworkControl*)e->target,
e->index,
&e->parameters);
break;
#endif //DLMS_IGNORE_ZIG_BEE_NETWORK_CONTROL
#ifndef DLMS_IGNORE_CHARGE
case DLMS_OBJECT_TYPE_CHARGE:
ret = invoke_Charge(
(gxCharge*)e->target,
e->index,
&e->parameters);
break;
#endif //DLMS_IGNORE_CHARGE
#ifndef DLMS_IGNORE_CREDIT
case DLMS_OBJECT_TYPE_CREDIT:
ret = invoke_Credit(
(gxCredit*)e->target,
e->index,
&e->parameters);
break;
#endif //DLMS_IGNORE_CREDIT
#ifndef DLMS_IGNORE_TOKEN_GATEWAY
case DLMS_OBJECT_TYPE_TOKEN_GATEWAY:
ret = invoke_gxTokenGateway(
(gxTokenGateway*)e->target,
e->index,
&e->parameters);
break;
#endif //DLMS_IGNORE_TOKEN_GATEWAY
#ifndef DLMS_IGNORE_ASSOCIATION_SHORT_NAME
case DLMS_OBJECT_TYPE_ASSOCIATION_SHORT_NAME:
#ifndef DLMS_IGNORE_ASSOCIATION_SHORT_NAME
ret = invoke_AssociationShortName(settings, e);
#endif //DLMS_IGNORE_ASSOCIATION_SHORT_NAME
break;
#endif //ASSOCIATION_SHORT_NAME
#ifndef DLMS_IGNORE_ASSOCIATION_LOGICAL_NAME
case DLMS_OBJECT_TYPE_ASSOCIATION_LOGICAL_NAME:
ret = invoke_AssociationLogicalName(settings, e);
break;
#endif //DLMS_IGNORE_ASSOCIATION_LOGICAL_NAME
#ifndef DLMS_IGNORE_IMAGE_TRANSFER
case DLMS_OBJECT_TYPE_IMAGE_TRANSFER:
ret = invoke_ImageTransfer((gxImageTransfer*)e->target, e);
break;
#endif //DLMS_IGNORE_IMAGE_TRANSFER
#ifndef DLMS_IGNORE_SAP_ASSIGNMENT
case DLMS_OBJECT_TYPE_SAP_ASSIGNMENT:
ret = invoke_SapAssigment((gxSapAssignment*)e->target, e);
break;
#endif //DLMS_IGNORE_SAP_ASSIGNMENT
#ifndef DLMS_IGNORE_SECURITY_SETUP
case DLMS_OBJECT_TYPE_SECURITY_SETUP:
ret = invoke_SecuritySetup(settings, (gxSecuritySetup*)e->target, e);
break;
#endif //DLMS_IGNORE_SECURITY_SETUP
#ifndef DLMS_IGNORE_COMPACT_DATA
case DLMS_OBJECT_TYPE_COMPACT_DATA:
ret = invoke_CompactData(settings, (gxCompactData*)e->target, e->index);
break;
#endif //DLMS_IGNORE_COMPACT_DATA
#ifndef DLMS_IGNORE_DISCONNECT_CONTROL
case DLMS_OBJECT_TYPE_DISCONNECT_CONTROL:
ret = invoke_DisconnectControl(settings, (gxDisconnectControl*)e->target, e->index);
break;
#endif //DLMS_IGNORE_DISCONNECT_CONTROL
#ifndef DLMS_IGNORE_LLC_SSCS_SETUP
case DLMS_OBJECT_TYPE_LLC_SSCS_SETUP:
ret = invoke_LlcSscsSetup((gxLlcSscsSetup*)e->target, e->index);
break;
#endif //DLMS_IGNORE_LLC_SSCS_SETUP
#ifndef DLMS_IGNORE_PRIME_NB_OFDM_PLC_PHYSICAL_LAYER_COUNTERS
case DLMS_OBJECT_TYPE_PRIME_NB_OFDM_PLC_PHYSICAL_LAYER_COUNTERS:
ret = invoke_PrimeNbOfdmPlcPhysicalLayerCounters((gxPrimeNbOfdmPlcPhysicalLayerCounters*)e->target, e->index);
break;
#endif //DLMS_IGNORE_PRIME_NB_OFDM_PLC_PHYSICAL_LAYER_COUNTERS
#ifndef DLMS_IGNORE_PRIME_NB_OFDM_PLC_MAC_COUNTERS
case DLMS_OBJECT_TYPE_PRIME_NB_OFDM_PLC_MAC_COUNTERS:
ret = invoke_PrimeNbOfdmPlcMacCounters((gxPrimeNbOfdmPlcMacCounters*)e->target, e->index);
break;
#endif //DLMS_IGNORE_PRIME_NB_OFDM_PLC_MAC_COUNTERS
#ifndef DLMS_IGNORE_PRIME_NB_OFDM_PLC_MAC_NETWORK_ADMINISTRATION_DATA
case DLMS_OBJECT_TYPE_PRIME_NB_OFDM_PLC_MAC_NETWORK_ADMINISTRATION_DATA:
ret = invoke_PrimeNbOfdmPlcMacNetworkAdministrationData((gxPrimeNbOfdmPlcMacNetworkAdministrationData*)e->target, e->index);
break;
#endif //DLMS_IGNORE_PRIME_NB_OFDM_PLC_MAC_NETWORK_ADMINISTRATION_DATA
#ifndef DLMS_IGNORE_SPECIAL_DAYS_TABLE
case DLMS_OBJECT_TYPE_SPECIAL_DAYS_TABLE:
ret = invoke_SpecialDaysTable((gxSpecialDaysTable*)e->target, e);
break;
#endif //DLMS_IGNORE_SPECIAL_DAYS_TABLE
#ifndef DLMS_IGNORE_REGISTER_ACTIVATION
case DLMS_OBJECT_TYPE_REGISTER_ACTIVATION:
ret = invoke_RegisterActivation(settings, (gxRegisterActivation*)e->target, e);
break;
#endif //DLMS_IGNORE_REGISTER_ACTIVATION
#ifndef DLMS_IGNORE_ACTIVITY_CALENDAR
case DLMS_OBJECT_TYPE_ACTIVITY_CALENDAR:
ret = invoke_ActivityCalendar(e);
break;
#endif //DLMS_IGNORE_ACTIVITY_CALENDAR
#ifndef DLMS_IGNORE_ARRAY_MANAGER
case DLMS_OBJECT_TYPE_ARRAY_MANAGER:
ret = invoke_ArrayManager(settings, e);
break;
#endif //DLMS_IGNORE_ARRAY_MANAGER
#ifndef DLMS_IGNORE_G3_PLC_MAC_SETUP
case DLMS_OBJECT_TYPE_G3_PLC_MAC_SETUP:
ret = invoke_G3_PLC_MAC_Setup(settings, (gxG3PlcMacSetup*)e->target, e);
break;
#endif //DLMS_IGNORE_G3_PLC_MAC_SETUP
default:
//Unknown type.
ret = DLMS_ERROR_CODE_INVALID_PARAMETER;
}
return ret;
}
#endif //DLMS_IGNORE_SERVER
Reference in New Issue View Git Blame Copy Permalink