int
mmsServer_handleGetVariableAccessAttributesRequest(
MmsServerConnection* connection,
GetVariableAccessAttributesRequest_t* request,
int invokeId,
ByteBuffer* response)
{
if (request->present == GetVariableAccessAttributesRequest_PR_name) {
if (request->choice.name.present == ObjectName_PR_domainspecific) {
Identifier_t domainId = request->choice.name.choice.domainspecific.domainId;
Identifier_t nameId = request->choice.name.choice.domainspecific.itemId;
char* domainIdStr = createStringFromBuffer(domainId.buf, domainId.size);
char* nameIdStr = createStringFromBuffer(nameId.buf, nameId.size);
if (DEBUG) printf("getVariableAccessAttributes domainId: %s nameId: %s\n", domainIdStr, nameIdStr);
createVariableAccessAttributesResponse(connection, domainIdStr, nameIdStr, invokeId, response);
free(domainIdStr);
free(nameIdStr);
}
else {
if (DEBUG) printf("GetVariableAccessAttributesRequest with name other than domainspecific is not supported!\n");
return -1;
}
}
else {
if (DEBUG) printf("GetVariableAccessAttributesRequest with address not supported!\n");
return -1;
}
return 0;
}
char*
mmsMsg_createStringFromAsnIdentifier(Identifier_t identifier)
{
char* str = createStringFromBuffer(identifier.buf, identifier.size);
return str;
}
int
mmsServer_handleGetVariableAccessAttributesRequest(
MmsServerConnection* connection,
uint8_t* buffer, int bufPos, int maxBufPos,
int invokeId,
ByteBuffer* response)
{
int retVal = 0;
GetVariableAccessAttributesRequest_t* request = 0;
asn_dec_rval_t rval; /* Decoder return value */
rval = ber_decode(NULL, &asn_DEF_GetVariableAccessAttributesRequest,
(void**) &request, buffer + bufPos, maxBufPos - bufPos);
if (request->present == GetVariableAccessAttributesRequest_PR_name) {
if (request->choice.name.present == ObjectName_PR_domainspecific) {
Identifier_t domainId = request->choice.name.choice.domainspecific.domainId;
Identifier_t nameId = request->choice.name.choice.domainspecific.itemId;
char* domainIdStr = createStringFromBuffer(domainId.buf, domainId.size);
char* nameIdStr = createStringFromBuffer(nameId.buf, nameId.size);
if (DEBUG) printf("getVariableAccessAttributes domainId: %s nameId: %s\n", domainIdStr, nameIdStr);
createVariableAccessAttributesResponse(connection, domainIdStr, nameIdStr, invokeId, response);
free(domainIdStr);
free(nameIdStr);
}
else {
if (DEBUG) printf("GetVariableAccessAttributesRequest with name other than domainspecific is not supported!\n");
retVal = -1;
}
}
else {
if (DEBUG) printf("GetVariableAccessAttributesRequest with address not supported!\n");
retVal = -1;
}
asn_DEF_GetVariableAccessAttributesRequest.free_struct(&asn_DEF_GetVariableAccessAttributesRequest, request, 0);
return retVal;
}
bool
mmsClient_parseGetNameListResponse(LinkedList* nameList, ByteBuffer* message, uint32_t* invokeId)
{
MmsPdu_t* mmsPdu = 0;
bool moreFollows = false;
asn_dec_rval_t rval;
/* Decoder return value */
rval = ber_decode(NULL, &asn_DEF_MmsPdu,
(void**) &mmsPdu, ByteBuffer_getBuffer(message), ByteBuffer_getSize(message));
if (DEBUG) xer_fprint(stdout, &asn_DEF_MmsPdu, mmsPdu);
if (mmsPdu->present == MmsPdu_PR_confirmedResponsePdu) {
*invokeId = mmsClient_getInvokeId(&mmsPdu->choice.confirmedResponsePdu);
if (mmsPdu->choice.confirmedResponsePdu.confirmedServiceResponse.present == ConfirmedServiceResponse_PR_getNameList) {
GetNameListResponse_t* response =
&(mmsPdu->choice.confirmedResponsePdu.confirmedServiceResponse.choice.getNameList);
int variableCount;
int i;
LinkedList element;
if ((response->moreFollows != NULL) && (*(response->moreFollows) != 0))
moreFollows = true;
if (*nameList == NULL)
*nameList = LinkedList_create();
variableCount = response->listOfIdentifier.list.count;
element = LinkedList_getLastElement(*nameList);
for (i = 0; i < variableCount; i++) {
char* variableName =
createStringFromBuffer(response->listOfIdentifier.list.array[i]->buf,
response->listOfIdentifier.list.array[i]->size);
element = LinkedList_insertAfter(element, variableName);
}
}
else {
printf("parseMmsGetNameListResponse: NOT A GetNameList RESPONSE!\n");
}
}
else {
printf("parseMmsGetNameListResponse: NOT A CONFIRMED RESPONSE!\n");
}
asn_DEF_MmsPdu.free_struct(&asn_DEF_MmsPdu, mmsPdu, 0);
return moreFollows;
}
static MmsNamedVariableList
createNamedVariableList(MmsDevice* device,
DefineNamedVariableListRequest_t* request,
char* variableListName)
{
MmsNamedVariableList namedVariableList = MmsNamedVariableList_create(variableListName, true);
int variableCount = request->listOfVariable.list.count;
int i;
for (i = 0; i < variableCount; i++) {
VariableSpecification_t* varSpec =
&request->listOfVariable.list.array[i]->variableSpecification;
if (varSpec->present == VariableSpecification_PR_name) {
char* variableName = createStringFromBuffer(
varSpec->choice.name.choice.domainspecific.itemId.buf,
varSpec->choice.name.choice.domainspecific.itemId.size);
char* domainId = createStringFromBuffer(
varSpec->choice.name.choice.domainspecific.domainId.buf,
varSpec->choice.name.choice.domainspecific.domainId.size);
MmsDomain* domain = MmsDevice_getDomain(device, domainId);
MmsNamedVariableListEntry variable =
MmsNamedVariableListEntry_create(domain, variableName);
MmsNamedVariableList_addVariable(namedVariableList, variable);
free(domainId);
free(variableName);
}
else {
MmsNamedVariableList_destroy(namedVariableList);
namedVariableList = NULL;
break;
}
}
return namedVariableList;
}
void
mmsServer_handleGetNamedVariableListAttributesRequest(
MmsServerConnection* connection,
GetNamedVariableListAttributesRequest_t* request,
int invokeId,
ByteBuffer* response)
{
if (request->present == ObjectName_PR_domainspecific) {
char* domainName = createStringFromBuffer(
request->choice.domainspecific.domainId.buf,
request->choice.domainspecific.domainId.size);
char* itemName = createStringFromBuffer(
request->choice.domainspecific.itemId.buf,
request->choice.domainspecific.itemId.size);
MmsDevice* mmsDevice = MmsServer_getDevice(connection->server);
MmsDomain* domain = MmsDevice_getDomain(mmsDevice, domainName);
if (domain != NULL) {
MmsNamedVariableList variableList =
MmsDomain_getNamedVariableList(domain, itemName);
if (variableList != NULL)
createGetNamedVariableListAttributesResponse(invokeId, response, variableList, domainName);
else
mmsServer_createConfirmedErrorPdu(invokeId, response, MMS_ERROR_TYPE_OBJECT_NON_EXISTENT);
}
else
mmsServer_createConfirmedErrorPdu(invokeId, response, MMS_ERROR_TYPE_OBJECT_NON_EXISTENT);
free(domainName);
free(itemName);
}
else {
mmsServer_createConfirmedErrorPdu(invokeId, response, MMS_ERROR_TYPE_OBJECT_ACCESS_UNSUPPORTED);
}
}
LinkedList
mmsClient_parseGetNameListResponse(ByteBuffer* message, uint32_t* invokeId)
{
MmsPdu_t* mmsPdu = 0; /* allow asn1c to allocate structure */
LinkedList returnList = NULL;
asn_dec_rval_t rval;
/* Decoder return value */
rval = ber_decode(NULL, &asn_DEF_MmsPdu,
(void**) &mmsPdu, ByteBuffer_getBuffer(message), ByteBuffer_getSize(message));
if (DEBUG) xer_fprint(stdout, &asn_DEF_MmsPdu, mmsPdu);
if (mmsPdu->present == MmsPdu_PR_confirmedResponsePdu) {
*invokeId = mmsClient_getInvokeId(&mmsPdu->choice.confirmedResponsePdu);
if (mmsPdu->choice.confirmedResponsePdu.confirmedServiceResponse.present == ConfirmedServiceResponse_PR_getNameList) {
GetNameListResponse_t* response =
&(mmsPdu->choice.confirmedResponsePdu.confirmedServiceResponse.choice.getNameList);
LinkedList variableNameList = LinkedList_create();
int variableCount = response->listOfIdentifier.list.count;
int i;
for (i = 0; i < variableCount; i++) {
char* variableName =
createStringFromBuffer(response->listOfIdentifier.list.array[i]->buf,
response->listOfIdentifier.list.array[i]->size);
LinkedList_add(variableNameList, variableName);
}
returnList = variableNameList;
}
else {
printf("parseMmsGetNameListResponse: NOT A GetNameList RESPONSE!\n");
}
}
else {
printf("parseMmsGetNameListResponse: NOT A CONFIRMED RESPONSE!\n");
}
asn_DEF_MmsPdu.free_struct(&asn_DEF_MmsPdu, mmsPdu, 0);
return returnList;
}
bool
mmsClient_parseGetNameListResponse(LinkedList* nameList, ByteBuffer* message, uint32_t* invokeId)
{
bool moreFollows = true;
uint8_t* buffer = message->buffer;
int maxBufPos = message->size;
int bufPos = 0;
int length;
uint8_t tag = buffer[bufPos++];
if (tag == 0xa2) {
// TODO parse confirmed error PDU
goto exit_error;
}
if (tag != 0xa1) goto exit_error;
bufPos = BerDecoder_decodeLength(buffer, &length, bufPos, maxBufPos);
if (bufPos < 0) goto exit_error;
/* get invokeId */
tag = buffer[bufPos++];
if (tag != 0x02) goto exit_error;
bufPos = BerDecoder_decodeLength(buffer, &length, bufPos, maxBufPos);
if (bufPos < 0) goto exit_error;
if (invokeId != NULL)
*invokeId = BerDecoder_decodeUint32(buffer, length, bufPos);
bufPos += length;
tag = buffer[bufPos++];
if (tag != 0xa1) goto exit_error;
bufPos = BerDecoder_decodeLength(buffer, &length, bufPos, maxBufPos);
if (bufPos < 0) goto exit_error;
tag = buffer[bufPos++];
if (tag != 0xa0) goto exit_error;
bufPos = BerDecoder_decodeLength(buffer, &length, bufPos, maxBufPos);
if (bufPos < 0) goto exit_error;
int listEndPos = bufPos + length;
if (listEndPos > maxBufPos) goto exit_error;
if (*nameList == NULL)
*nameList = LinkedList_create();
LinkedList element = LinkedList_getLastElement(*nameList);
while (bufPos < listEndPos) {
tag = buffer[bufPos++];
if (tag != 0x1a) goto exit_error;
bufPos = BerDecoder_decodeLength(buffer, &length, bufPos, maxBufPos);
if (bufPos < 0) goto exit_error;
char* variableName = createStringFromBuffer(buffer + bufPos, length);
element = LinkedList_insertAfter(element, variableName);
bufPos += length;
}
if (bufPos < maxBufPos) {
tag = buffer[bufPos++];
if (tag != 0x81) goto exit_error;
bufPos = BerDecoder_decodeLength(buffer, &length, bufPos, maxBufPos);
if (bufPos < 0) goto exit_error;
if (length != 1) goto exit_error;
if (buffer[bufPos++] > 0)
moreFollows = true;
else
moreFollows = false;
}
return moreFollows;
exit_error:
if (*nameList != NULL) {
LinkedList_destroy(*nameList);
}
if (DEBUG) printf("parseNameListResponse: error parsing message!\n");
return false;
}
/**********************************************************************************************
* mmsServer_handleWriteRequest
* возвращает MmsServiceError
*********************************************************************************************/
int mmsServer_handleWriteRequest( MmsServerConnection* connection, WriteRequest_t* writeRequest, int invokeId, ByteBuffer* response)
{
ListOfVariableSeq_t* varSpec;
Identifier_t domainId;
char* domainIdStr;
MmsDevice* device;
MmsDomain* domain;
Identifier_t nameId;
char* nameIdStr;
MmsTypeSpecification* variable;
AlternateAccess_t* alternateAccess;
Data_t* dataElement;
MmsValue* value;
MmsValueIndication valueIndication;
if (writeRequest->variableAccessSpecification.choice.listOfVariable.list.count != 1)
return -1;
varSpec = writeRequest->variableAccessSpecification.choice.listOfVariable.list.array[0];
if (varSpec->variableSpecification.present != VariableSpecification_PR_name) {
createMmsWriteResponse(connection, invokeId, response, MMS_VALUE_ACCESS_DENIED);
return 0;
}
if (varSpec->variableSpecification.choice.name.present != ObjectName_PR_domainspecific) {
createMmsWriteResponse(connection, invokeId, response, MMS_VALUE_ACCESS_DENIED);
return 0;
}
domainId = varSpec->variableSpecification.choice.name.choice.domainspecific.domainId;
domainIdStr = createStringFromBuffer(domainId.buf, domainId.size);
device = MmsServer_getDevice(connection->server);
domain = MmsDevice_getDomain(device, domainIdStr);
free(domainIdStr);
if (domain == NULL) {
createMmsWriteResponse(connection, invokeId, response, MMS_VALUE_ACCESS_DENIED);
return 0;
}
nameId = varSpec->variableSpecification.choice.name.choice.domainspecific.itemId;
nameIdStr = createStringFromBuffer(nameId.buf, nameId.size);
variable = MmsDomain_getNamedVariable(domain, nameIdStr);
if (variable == NULL)
goto return_access_denied;
if (writeRequest->listOfData.list.count != 1)
goto return_access_denied;
alternateAccess = varSpec->alternateAccess;
if (alternateAccess != NULL) {
if (variable->type != MMS_ARRAY)
goto return_access_denied;
if (!mmsServer_isIndexAccess(alternateAccess))
goto return_access_denied;
}
dataElement = writeRequest->listOfData.list.array[0];
value = mmsMsg_parseDataElement(dataElement);
if (value == NULL)
goto return_access_denied;
if (alternateAccess != NULL) {
MmsValue* cachedArray = MmsServer_getValueFromCache(connection->server, domain, nameIdStr);
int index;
MmsValue* elementValue;
if (cachedArray == NULL) {
MmsValue_delete(value);
goto return_access_denied;
}
index = mmsServer_getLowIndex(alternateAccess);
elementValue = MmsValue_getElement(cachedArray, index);
if (elementValue == NULL) {
MmsValue_delete(value);
goto return_access_denied;
}
if (MmsValue_update(elementValue, value) == false) {
MmsValue_delete(value);
goto return_access_denied;
}
}
MmsServer_lockModel(connection->server);
valueIndication = mmsServer_setValue(connection->server, domain, nameIdStr, value, connection);
MmsServer_unlockModel(connection->server);
createMmsWriteResponse(connection, invokeId, response, valueIndication);
MmsValue_delete(value);
free(nameIdStr);
return 0;
return_access_denied:
createMmsWriteResponse(connection, invokeId, response, MMS_VALUE_ACCESS_DENIED);
free(nameIdStr);
return 0;
}
void
mmsServer_handleDefineNamedVariableListRequest(
MmsServerConnection* connection,
DefineNamedVariableListRequest_t* request,
int invokeId,
ByteBuffer* response)
{
MmsDevice* device = MmsServer_getDevice(connection->server);
if (request->variableListName.present == ObjectName_PR_domainspecific) {
MmsNamedVariableList namedVariableList;
char* variableListName;
char* domainName = createStringFromBuffer(
request->variableListName.choice.domainspecific.domainId.buf,
request->variableListName.choice.domainspecific.domainId.size);
MmsDomain* domain = MmsDevice_getDomain(device, domainName);
free(domainName);
if (domain == NULL) {
mmsServer_createConfirmedErrorPdu(invokeId, response, MMS_ERROR_TYPE_OBJECT_NON_EXISTENT);
return;
}
variableListName = createStringFromBuffer(
request->variableListName.choice.domainspecific.itemId.buf,
request->variableListName.choice.domainspecific.itemId.size);
namedVariableList = createNamedVariableList(device,
request, variableListName);
free(variableListName);
if (namedVariableList != NULL) {
MmsDomain_addNamedVariableList(domain, namedVariableList);
createDefineNamedVariableListResponse(invokeId, response);
}
else
mmsServer_createConfirmedErrorPdu(invokeId, response, MMS_ERROR_TYPE_OBJECT_ACCESS_UNSUPPORTED);
}
else if (request->variableListName.present == ObjectName_PR_aaspecific) {
char* variableListName = createStringFromBuffer(
request->variableListName.choice.aaspecific.buf,
request->variableListName.choice.aaspecific.size);
MmsNamedVariableList namedVariableList = createNamedVariableList(device,
request, variableListName);
if (namedVariableList != NULL) {
MmsServerConnection_addNamedVariableList(connection, namedVariableList);
createDefineNamedVariableListResponse(invokeId, response);
}
else
mmsServer_createConfirmedErrorPdu(invokeId, response, MMS_ERROR_TYPE_OBJECT_ACCESS_UNSUPPORTED);
free(variableListName);
}
else
mmsServer_createConfirmedErrorPdu(invokeId, response, MMS_ERROR_TYPE_OBJECT_ACCESS_UNSUPPORTED);
}
MmsServerIdentity*
mmsClient_parseIdentifyResponse(MmsConnection self)
{
uint8_t* buffer = self->lastResponse->buffer;
int maxBufPos = self->lastResponse->size;
int bufPos = self->lastResponseBufPos;
int length;
MmsServerIdentity* identityInfo = NULL;
uint8_t tag = buffer[bufPos++];
if (tag != 0xa2)
goto exit_error;
bufPos = BerDecoder_decodeLength(buffer, &length, bufPos, maxBufPos);
if (bufPos < 0) goto exit_error;
int endPos = bufPos + length;
if (endPos > maxBufPos) {
if (DEBUG_MMS_CLIENT)
printf("mmsClient_parseIdentifyResponse: Message to short!\n");
goto exit_error;
}
char* vendorName = NULL;
char* modelName = NULL;
char* revision = NULL;
while (bufPos < endPos) {
tag = buffer[bufPos++];
bufPos = BerDecoder_decodeLength(buffer, &length, bufPos, maxBufPos);
switch (tag) {
case 0x80: /* vendorName */
vendorName = createStringFromBuffer(buffer + bufPos, length);
bufPos += length;
break;
case 0x81: /* modelName */
modelName = createStringFromBuffer(buffer + bufPos, length);
bufPos += length;
break;
case 0x82: /* revision */
revision = createStringFromBuffer(buffer + bufPos, length);
bufPos += length;
break;
case 0x83: /* list of abstract syntaxes */
bufPos += length;
break;
}
}
identityInfo = (MmsServerIdentity*) malloc(sizeof(MmsServerIdentity));
identityInfo->vendorName = vendorName;
identityInfo->modelName = modelName;
identityInfo->revision = revision;
exit_error:
return identityInfo;
}
void
mmsServer_handleWriteRequest(
MmsServerConnection* connection,
uint8_t* buffer, int bufPos, int maxBufPos,
uint32_t invokeId,
ByteBuffer* response)
{
WriteRequest_t* writeRequest = 0;
MmsPdu_t* mmsPdu = 0;
asn_dec_rval_t rval; /* Decoder return value */
rval = ber_decode(NULL, &asn_DEF_MmsPdu, (void**) &mmsPdu, buffer, CONFIG_MMS_MAXIMUM_PDU_SIZE);
if (rval.code != RC_OK) {
mmsServer_writeMmsRejectPdu(&invokeId, MMS_ERROR_REJECT_INVALID_PDU, response);
return;
}
writeRequest = &(mmsPdu->choice.confirmedRequestPdu.confirmedServiceRequest.choice.write);
int numberOfWriteItems = writeRequest->variableAccessSpecification.choice.listOfVariable.list.count;
if (numberOfWriteItems < 1) {
mmsServer_writeMmsRejectPdu(&invokeId, MMS_ERROR_REJECT_REQUEST_INVALID_ARGUMENT, response);
return;
}
if (numberOfWriteItems > CONFIG_MMS_WRITE_SERVICE_MAX_NUMBER_OF_WRITE_ITEMS) {
mmsServer_writeMmsRejectPdu(&invokeId, MMS_ERROR_REJECT_OTHER, response);
return;
}
if (writeRequest->listOfData.list.count != numberOfWriteItems) {
mmsServer_writeMmsRejectPdu(&invokeId, MMS_ERROR_REJECT_REQUEST_INVALID_ARGUMENT, response);
return;
}
MmsDataAccessError accessResults[CONFIG_MMS_WRITE_SERVICE_MAX_NUMBER_OF_WRITE_ITEMS * sizeof(MmsDataAccessError)];
bool sendResponse = true;
int i;
for (i = 0; i < numberOfWriteItems; i++) {
ListOfVariableSeq_t* varSpec =
writeRequest->variableAccessSpecification.choice.listOfVariable.list.array[i];
if (varSpec->variableSpecification.present != VariableSpecification_PR_name) {
accessResults[i] = DATA_ACCESS_ERROR_OBJECT_ACCESS_UNSUPPORTED;
continue;
}
if (varSpec->variableSpecification.choice.name.present != ObjectName_PR_domainspecific) {
accessResults[i] = DATA_ACCESS_ERROR_OBJECT_ACCESS_UNSUPPORTED;
continue;
}
Identifier_t domainId = varSpec->variableSpecification.choice.name.choice.domainspecific.domainId;
char* domainIdStr = createStringFromBuffer(domainId.buf, domainId.size);
MmsDevice* device = MmsServer_getDevice(connection->server);
MmsDomain* domain = MmsDevice_getDomain(device, domainIdStr);
free(domainIdStr);
if (domain == NULL) {
accessResults[i] = DATA_ACCESS_ERROR_OBJECT_NONE_EXISTENT;
continue;
}
Identifier_t nameId = varSpec->variableSpecification.choice.name.choice.domainspecific.itemId;
char* nameIdStr = createStringFromBuffer(nameId.buf, nameId.size);
MmsVariableSpecification* variable = MmsDomain_getNamedVariable(domain, nameIdStr);
if (variable == NULL) {
free(nameIdStr);
accessResults[i] = DATA_ACCESS_ERROR_OBJECT_NONE_EXISTENT;
continue;
}
AlternateAccess_t* alternateAccess = varSpec->alternateAccess;
if (alternateAccess != NULL) {
if (variable->type != MMS_ARRAY) {
free(nameIdStr);
accessResults[i] = DATA_ACCESS_ERROR_OBJECT_ATTRIBUTE_INCONSISTENT;
continue;
}
if (!mmsServer_isIndexAccess(alternateAccess)) {
free(nameIdStr);
accessResults[i] = DATA_ACCESS_ERROR_OBJECT_ACCESS_UNSUPPORTED;
continue;
}
}
Data_t* dataElement = writeRequest->listOfData.list.array[i];
MmsValue* value = mmsMsg_parseDataElement(dataElement);
if (value == NULL) {
free(nameIdStr);
accessResults[i] = DATA_ACCESS_ERROR_OBJECT_ATTRIBUTE_INCONSISTENT;
continue;
}
if (alternateAccess != NULL) {
MmsValue* cachedArray = MmsServer_getValueFromCache(connection->server, domain, nameIdStr);
if (cachedArray == NULL) {
free(nameIdStr);
MmsValue_delete(value);
accessResults[i] = DATA_ACCESS_ERROR_OBJECT_ATTRIBUTE_INCONSISTENT;
continue;
}
int index = mmsServer_getLowIndex(alternateAccess);
MmsValue* elementValue = MmsValue_getElement(cachedArray, index);
if (elementValue == NULL) {
free(nameIdStr);
MmsValue_delete(value);
accessResults[i] = DATA_ACCESS_ERROR_OBJECT_ATTRIBUTE_INCONSISTENT;
continue;
}
if (MmsValue_update(elementValue, value) == false) {
free(nameIdStr);
MmsValue_delete(value);
accessResults[i] = DATA_ACCESS_ERROR_TYPE_INCONSISTENT;
continue;
}
free(nameIdStr);
MmsValue_delete(value);
accessResults[i] = DATA_ACCESS_ERROR_SUCCESS;
continue;
}
MmsDataAccessError valueIndication =
mmsServer_setValue(connection->server, domain, nameIdStr, value, connection);
if (valueIndication == DATA_ACCESS_ERROR_NO_RESPONSE)
sendResponse = false;
accessResults[i] = valueIndication;
MmsValue_delete(value);
free(nameIdStr);
}
if (sendResponse) {
mmsServer_createMmsWriteResponse(connection, invokeId, response, numberOfWriteItems, accessResults);
}
asn_DEF_MmsPdu.free_struct(&asn_DEF_MmsPdu, mmsPdu, 0);
}
int
mmsServer_handleGetVariableAccessAttributesRequest(
MmsServerConnection connection,
uint8_t* buffer, int bufPos, int maxBufPos,
uint32_t invokeId,
ByteBuffer* response)
{
int retVal = 0;
GetVariableAccessAttributesRequest_t* request = 0;
asn_dec_rval_t rval; /* Decoder return value */
rval = ber_decode(NULL, &asn_DEF_GetVariableAccessAttributesRequest,
(void**) &request, buffer + bufPos, maxBufPos - bufPos);
if (rval.code == RC_OK) {
if (request->present == GetVariableAccessAttributesRequest_PR_name) {
if (request->choice.name.present == ObjectName_PR_domainspecific) {
Identifier_t domainId = request->choice.name.choice.domainspecific.domainId;
Identifier_t nameId = request->choice.name.choice.domainspecific.itemId;
char* domainIdStr = createStringFromBuffer(domainId.buf, domainId.size);
char* nameIdStr = createStringFromBuffer(nameId.buf, nameId.size);
if (DEBUG_MMS_SERVER)
printf("MMS_SERVER: getVariableAccessAttributes domainId: %s nameId: %s\n", domainIdStr, nameIdStr);
createVariableAccessAttributesResponse(connection, domainIdStr, nameIdStr, invokeId, response);
GLOBAL_FREEMEM(domainIdStr);
GLOBAL_FREEMEM(nameIdStr);
}
#if (CONFIG_MMS_SUPPORT_VMD_SCOPE_NAMED_VARIABLES == 1)
else if (request->choice.name.present == ObjectName_PR_vmdspecific) {
Identifier_t nameId = request->choice.name.choice.vmdspecific;
char* nameIdStr = createStringFromBuffer(nameId.buf, nameId.size);
if (DEBUG_MMS_SERVER) printf("MMS_SERVER: getVariableAccessAttributes (VMD specific) nameId: %s\n", nameIdStr);
createVariableAccessAttributesResponse(connection, NULL, nameIdStr, invokeId, response);
GLOBAL_FREEMEM(nameIdStr);
}
#endif /* (CONFIG_MMS_SUPPORT_VMD_SCOPE_NAMED_VARIABLES == 1) */
else {
if (DEBUG_MMS_SERVER) printf("GetVariableAccessAttributesRequest with name other than domainspecific is not supported!\n");
retVal = -1;
}
}
else {
if (DEBUG_MMS_SERVER) printf("GetVariableAccessAttributesRequest with address not supported!\n");
retVal = -1;
}
}
else {
if (DEBUG_MMS_SERVER) printf("GetVariableAccessAttributesRequest parsing request failed!\n");
retVal = -1;
}
asn_DEF_GetVariableAccessAttributesRequest.free_struct(&asn_DEF_GetVariableAccessAttributesRequest, request, 0);
return retVal;
}
static MmsVariableSpecification*
createTypeSpecification(TypeSpecification_t* asnTypeSpec) {
MmsVariableSpecification* typeSpec = (MmsVariableSpecification*)
GLOBAL_CALLOC(1, sizeof(MmsVariableSpecification));
switch (asnTypeSpec->present) {
case TypeSpecification_PR_structure:
{
typeSpec->type = MMS_STRUCTURE;
int elementCount = asnTypeSpec->choice.structure.components.list.count;
typeSpec->typeSpec.structure.elementCount = elementCount;
typeSpec->typeSpec.structure.elements = (MmsVariableSpecification**)
GLOBAL_CALLOC(elementCount, sizeof(MmsVariableSpecification*));
int i;
for (i = 0; i < elementCount; i++) {
char* name = createStringFromBuffer(
asnTypeSpec->choice.structure.components.list.array[i]->componentName->buf,
asnTypeSpec->choice.structure.components.list.array[i]->componentName->size);
typeSpec->typeSpec.structure.elements[i] =
createTypeSpecification(asnTypeSpec->choice.structure.components.
list.array[i]->componentType);
typeSpec->typeSpec.structure.elements[i]->name = name;
}
}
break;
case TypeSpecification_PR_array:
{
typeSpec->type = MMS_ARRAY;
long elementCount;
asn_INTEGER2long(&asnTypeSpec->choice.array.numberOfElements, &elementCount);
typeSpec->typeSpec.array.elementCount = elementCount;
typeSpec->typeSpec.array.elementTypeSpec =
createTypeSpecification(asnTypeSpec->choice.array.elementType);
}
break;
case TypeSpecification_PR_boolean:
typeSpec->type = MMS_BOOLEAN;
break;
case TypeSpecification_PR_bitstring:
typeSpec->type = MMS_BIT_STRING;
typeSpec->typeSpec.bitString = asnTypeSpec->choice.bitstring;
break;
case TypeSpecification_PR_integer:
typeSpec->type = MMS_INTEGER;
typeSpec->typeSpec.integer = asnTypeSpec->choice.integer;
break;
case TypeSpecification_PR_unsigned:
typeSpec->type = MMS_UNSIGNED;
typeSpec->typeSpec.unsignedInteger = asnTypeSpec->choice.Unsigned;
break;
case TypeSpecification_PR_floatingpoint:
typeSpec->type = MMS_FLOAT;
typeSpec->typeSpec.floatingpoint.exponentWidth =
asnTypeSpec->choice.floatingpoint.exponentwidth;
typeSpec->typeSpec.floatingpoint.formatWidth =
asnTypeSpec->choice.floatingpoint.formatwidth;
break;
case TypeSpecification_PR_octetstring:
typeSpec->type = MMS_OCTET_STRING;
typeSpec->typeSpec.octetString = asnTypeSpec->choice.octetstring;
break;
case TypeSpecification_PR_visiblestring:
typeSpec->type = MMS_VISIBLE_STRING;
typeSpec->typeSpec.visibleString = asnTypeSpec->choice.visiblestring;
break;
case TypeSpecification_PR_mMSString:
typeSpec->type = MMS_STRING;
typeSpec->typeSpec.mmsString = asnTypeSpec->choice.mMSString;
break;
case TypeSpecification_PR_utctime:
typeSpec->type = MMS_UTC_TIME;
break;
case TypeSpecification_PR_binarytime:
typeSpec->type = MMS_BINARY_TIME;
if (asnTypeSpec->choice.binarytime == 0)
typeSpec->typeSpec.binaryTime = 4;
else
typeSpec->typeSpec.binaryTime = 6;
break;
default:
printf("ERROR: unknown type in type specification\n");
break;
}
return typeSpec;
}
