RYTEC
/
libiec61850
mirror of https://github.com/mz-automation/libiec61850.git
6
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

- MMS client: add asynchronous function for get variable access attributes service

Browse Source
pull/93/head
Michael Zillgith 7 years ago
parent 5692d0246b
commit aa7e89684e
3 changed files with 362 additions and 213 deletions
Show Stats Download Patch File Download Diff File

19
src/mms/inc/mms_client_connection.h
Unescape Escape View File

@ -602,6 +602,15 @@ MmsVariableSpecification*
MmsConnection_getVariableAccessAttributes(MmsConnection self, MmsError* mmsError, MmsConnection_getVariableAccessAttributes(MmsConnection self, MmsError* mmsError,
const char* domainId, const char* itemId); const char* domainId, const char* itemId);
typedef void
(*MmsConnection_GetVariableAccessAttributesHandler) (int invokeId, void* parameter, MmsError mmsError, MmsVariableSpecification* spec);
uint32_t
MmsConnection_getVariableAccessAttributesAsync(MmsConnection self, MmsError* mmsError,
const char* domainId, const char* itemId,
MmsConnection_GetVariableAccessAttributesHandler, void* parameter);
/** /**
* \brief Read the values of a domain specific named variable list * \brief Read the values of a domain specific named variable list
* *
@ -755,6 +764,11 @@ MmsConnection_readNamedVariableListDirectoryAssociationSpecificAsync(MmsConnecti
bool bool
MmsConnection_deleteNamedVariableList(MmsConnection self, MmsError* mmsError, const char* domainId, const char* listName); MmsConnection_deleteNamedVariableList(MmsConnection self, MmsError* mmsError, const char* domainId, const char* listName);
uint32_t
MmsConnection_deleteNamedVariableListAsync(MmsConnection self, MmsError* mmsError, const char* domainId, const char* listName,
MmsConnection_GenericServiceHandler handler, void* parameter);
/** /**
* \brief Delete an association specific named variable list at the server. * \brief Delete an association specific named variable list at the server.
* *
@ -768,6 +782,11 @@ bool
MmsConnection_deleteAssociationSpecificNamedVariableList(MmsConnection self, MmsError* mmsError, MmsConnection_deleteAssociationSpecificNamedVariableList(MmsConnection self, MmsError* mmsError,
const char* listName); const char* listName);
uint32_t
MmsConnection_deleteAssociationSpecificNamedVariableListAsync(MmsConnection self, MmsError* mmsError, const char* listName,
MmsConnection_GenericServiceHandler handler, void* parameter);
/** /**
* \brief Create a new MmsVariableSpecification that can be used to define named variable lists. * \brief Create a new MmsVariableSpecification that can be used to define named variable lists.
* *

5
src/mms/inc_private/mms_client_internal.h
Unescape Escape View File

@ -64,10 +64,13 @@ typedef enum {
typedef enum { typedef enum {
MMS_CALL_TYPE_NONE, MMS_CALL_TYPE_NONE,
MMS_CALL_TYPE_READ_VARIABLE, MMS_CALL_TYPE_READ_VARIABLE,
MMS_CALL_TYPE_READ_MULTIPLE_VARIABLES,
MMS_CALL_TYPE_WRITE_VARIABLE, MMS_CALL_TYPE_WRITE_VARIABLE,
MMS_CALL_TYPE_WRITE_MULTIPLE_VARIABLES, MMS_CALL_TYPE_WRITE_MULTIPLE_VARIABLES,
MMS_CALL_TYPE_READ_NVL_DIRECTORY, MMS_CALL_TYPE_READ_NVL_DIRECTORY,
MMS_CALL_TYPE_DEFINE_NVL MMS_CALL_TYPE_DEFINE_NVL,
MMS_CALL_TYPE_DELETE_NVL,
MMS_CALL_TYPE_GET_VAR_ACCESS_ATTR
} eMmsOutstandingCallType; } eMmsOutstandingCallType;
struct sMmsOutstandingCall struct sMmsOutstandingCall

541
src/mms/iso_mms/client/mms_client_connection.c
Unescape Escape View File

@ -794,6 +794,22 @@ handleAsyncResponse(MmsConnection self, ByteBuffer* response, uint32_t bufPos, M
} }
} }
else if (outstandingCall->type == MMS_CALL_TYPE_READ_MULTIPLE_VARIABLES) {
MmsConnection_ReadVariableHandler handler =
(MmsConnection_ReadVariableHandler) outstandingCall->userCallback;
if (err != MMS_ERROR_NONE)
handler(outstandingCall->invokeId, outstandingCall->userParameter, err, NULL);
else {
if (response) {
MmsValue* value = mmsClient_parseReadResponse(response, NULL, true);
handler(outstandingCall->invokeId, outstandingCall->userParameter, MMS_ERROR_NONE, value);
}
}
}
else if (outstandingCall->type == MMS_CALL_TYPE_WRITE_VARIABLE) { else if (outstandingCall->type == MMS_CALL_TYPE_WRITE_VARIABLE) {
MmsConnection_WriteVariableHandler handler = MmsConnection_WriteVariableHandler handler =
@ -868,6 +884,37 @@ handleAsyncResponse(MmsConnection self, ByteBuffer* response, uint32_t bufPos, M
handler(outstandingCall->invokeId, outstandingCall->userParameter, err, success); handler(outstandingCall->invokeId, outstandingCall->userParameter, err, success);
} }
} }
else if (outstandingCall->type == MMS_CALL_TYPE_DELETE_NVL) {
MmsConnection_GenericServiceHandler handler =
(MmsConnection_GenericServiceHandler) outstandingCall->userCallback;
if (err != MMS_ERROR_NONE) {
handler(outstandingCall->invokeId, outstandingCall->userParameter, err, false);
}
else {
bool success = false;
if (mmsClient_parseDeleteNamedVariableListResponse(response, NULL))
success = true;
handler(outstandingCall->invokeId, outstandingCall->userParameter, err, success);
}
}
else if (outstandingCall->type == MMS_CALL_TYPE_GET_VAR_ACCESS_ATTR) {
MmsConnection_GetVariableAccessAttributesHandler handler =
(MmsConnection_GetVariableAccessAttributesHandler) outstandingCall->userCallback;
if (err != MMS_ERROR_NONE) {
handler(outstandingCall->invokeId, outstandingCall->userParameter, err, NULL);
}
else {
MmsVariableSpecification* typeSpec = mmsClient_parseGetVariableAccessAttributesResponse(response, NULL);
handler(outstandingCall->invokeId, outstandingCall->userParameter, err, typeSpec);
}
}
removeFromOutstandingCalls(self, outstandingCall->invokeId); removeFromOutstandingCalls(self, outstandingCall->invokeId);
@ -1746,27 +1793,23 @@ MmsConnection_getVariableListNamesAssociationSpecific(MmsConnection self, MmsErr
return mmsClient_getNameList(self, mmsError, NULL, MMS_OBJECT_CLASS_NAMED_VARIABLE_LIST, true); return mmsClient_getNameList(self, mmsError, NULL, MMS_OBJECT_CLASS_NAMED_VARIABLE_LIST, true);
} }
struct threeParameters struct readNVParameters
{ {
void* param1; Semaphore sem;
void* param2; MmsError err;
void* param3; MmsValue* value;
}; };
static void static void
readVariableHandler(int invokeId, void* parameter, MmsError mmsError, MmsValue* value) readVariableHandler(int invokeId, void* parameter, MmsError mmsError, MmsValue* value)
{ {
struct threeParameters* parameters = (struct threeParameters*) parameter; struct readNVParameters* parameters = (struct readNVParameters*) parameter;
Semaphore waitForResponse = (Semaphore) parameters->param1; parameters->err = mmsError;
MmsError* err = (MmsError*) parameters->param3; parameters->value = value;
parameters->param2 = value;
*err = mmsError;
/* unblock user thread */ /* unblock user thread */
Semaphore_post(waitForResponse); Semaphore_post(parameters->sem);
} }
uint32_t uint32_t
@ -1801,31 +1844,29 @@ MmsConnection_readVariable(MmsConnection self, MmsError* mmsError,
const char* domainId, const char* itemId) const char* domainId, const char* itemId)
{ {
MmsValue* value = NULL; MmsValue* value = NULL;
MmsError err = MMS_ERROR_NONE;
Semaphore waitForResponse = Semaphore_create(1); struct readNVParameters parameter;
Semaphore_wait(waitForResponse);
struct threeParameters parameter;
MmsError respErr = MMS_ERROR_NONE; parameter.sem = Semaphore_create(1);;
parameter.value = NULL;
parameter.err = MMS_ERROR_NONE;
parameter.param1 = waitForResponse; Semaphore_wait(parameter.sem);
parameter.param2 = NULL;
parameter.param3 = &respErr;
MmsConnection_readVariableAsync(self, &respErr, domainId, itemId, readVariableHandler, &parameter); MmsConnection_readVariableAsync(self, &err, domainId, itemId, readVariableHandler, &parameter);
if (respErr == MMS_ERROR_NONE) { if (err == MMS_ERROR_NONE) {
Semaphore_wait(waitForResponse); Semaphore_wait(parameter.sem);
value = (MmsValue*) parameter.param2; value = parameter.value;
err = parameter.err;
} }
Semaphore_destroy(waitForResponse); Semaphore_destroy(parameter.sem);
if (mmsError) if (mmsError)
*mmsError = respErr; *mmsError = err;
return value; return value;
} }
@ -1836,32 +1877,30 @@ MmsConnection_readArrayElements(MmsConnection self, MmsError* mmsError,
uint32_t startIndex, uint32_t numberOfElements) uint32_t startIndex, uint32_t numberOfElements)
{ {
MmsValue* value = NULL; MmsValue* value = NULL;
MmsError err = MMS_ERROR_NONE;
Semaphore waitForResponse = Semaphore_create(1); struct readNVParameters parameter;
Semaphore_wait(waitForResponse);
struct threeParameters parameter; parameter.sem = Semaphore_create(1);;
parameter.value = NULL;
parameter.err = MMS_ERROR_NONE;
MmsError respErr = MMS_ERROR_NONE; Semaphore_wait(parameter.sem);
parameter.param1 = waitForResponse; MmsConnection_readArrayElementsAsync(self, &err, domainId, itemId, startIndex, numberOfElements,
parameter.param2 = NULL;
parameter.param3 = &respErr;
MmsConnection_readArrayElementsAsync(self, &respErr, domainId, itemId, startIndex, numberOfElements,
readVariableHandler, &parameter); readVariableHandler, &parameter);
if (respErr == MMS_ERROR_NONE) { if (err == MMS_ERROR_NONE) {
Semaphore_wait(waitForResponse); Semaphore_wait(parameter.sem);
value = (MmsValue*) parameter.param2; value = parameter.value;
err = parameter.err;
} }
Semaphore_destroy(waitForResponse); Semaphore_destroy(parameter.sem);
if (mmsError) if (mmsError)
*mmsError = respErr; *mmsError = err;
return value; return value;
} }
@ -1900,32 +1939,30 @@ MmsConnection_readSingleArrayElementWithComponent(MmsConnection self, MmsError*
const char* domainId, const char* itemId, uint32_t index, const char* componentId) const char* domainId, const char* itemId, uint32_t index, const char* componentId)
{ {
MmsValue* value = NULL; MmsValue* value = NULL;
MmsError err = MMS_ERROR_NONE;
Semaphore waitForResponse = Semaphore_create(1); struct readNVParameters parameter;
Semaphore_wait(waitForResponse);
struct threeParameters parameter;
MmsError respErr = MMS_ERROR_NONE; parameter.sem = Semaphore_create(1);;
parameter.value = NULL;
parameter.err = MMS_ERROR_NONE;
parameter.param1 = waitForResponse; Semaphore_wait(parameter.sem);
parameter.param2 = NULL;
parameter.param3 = &respErr;
MmsConnection_readSingleArrayElementWithComponentAsync(self, &respErr, domainId, itemId, index, componentId, MmsConnection_readSingleArrayElementWithComponentAsync(self, &err, domainId, itemId, index, componentId,
readVariableHandler, &parameter); readVariableHandler, &parameter);
if (respErr == MMS_ERROR_NONE) { if (err == MMS_ERROR_NONE) {
Semaphore_wait(waitForResponse); Semaphore_wait(parameter.sem);
value = (MmsValue*) parameter.param2; value = parameter.value;
err = parameter.err;
} }
Semaphore_destroy(waitForResponse); Semaphore_destroy(parameter.sem);
if (mmsError) if (mmsError)
*mmsError = respErr; *mmsError = err;
return value; return value;
} }
@ -1965,32 +2002,30 @@ MmsConnection_readMultipleVariables(MmsConnection self, MmsError* mmsError,
const char* domainId, LinkedList /*<char*>*/items) const char* domainId, LinkedList /*<char*>*/items)
{ {
MmsValue* value = NULL; MmsValue* value = NULL;
MmsError err = MMS_ERROR_NONE;
Semaphore waitForResponse = Semaphore_create(1); struct readNVParameters parameter;
Semaphore_wait(waitForResponse);
struct threeParameters parameter;
MmsError respErr = MMS_ERROR_NONE; parameter.sem = Semaphore_create(1);;
parameter.value = NULL;
parameter.err = MMS_ERROR_NONE;
parameter.param1 = waitForResponse; Semaphore_wait(parameter.sem);
parameter.param2 = NULL;
parameter.param3 = &respErr;
MmsConnection_readMultipleVariablesAsync(self, &respErr, domainId, items, MmsConnection_readMultipleVariablesAsync(self, &err, domainId, items,
readVariableHandler, &parameter); readVariableHandler, &parameter);
if (respErr == MMS_ERROR_NONE) { if (err == MMS_ERROR_NONE) {
Semaphore_wait(waitForResponse); Semaphore_wait(parameter.sem);
value = (MmsValue*) parameter.param2; value = parameter.value;
err = parameter.err;
} }
Semaphore_destroy(waitForResponse); Semaphore_destroy(parameter.sem);
if (mmsError) if (mmsError)
*mmsError = respErr; *mmsError = err;
return value; return value;
} }
@ -2014,7 +2049,7 @@ MmsConnection_readMultipleVariablesAsync(MmsConnection self, MmsError* mmsError,
mmsClient_createReadRequestMultipleValues(invokeId, domainId, items, payload); mmsClient_createReadRequestMultipleValues(invokeId, domainId, items, payload);
MmsError err = sendAsyncRequest(self, invokeId, payload, MMS_CALL_TYPE_READ_VARIABLE, handler, parameter); MmsError err = sendAsyncRequest(self, invokeId, payload, MMS_CALL_TYPE_READ_MULTIPLE_VARIABLES, handler, parameter);
if (mmsError) if (mmsError)
*mmsError = err; *mmsError = err;
@ -2030,32 +2065,30 @@ MmsConnection_readNamedVariableListValues(MmsConnection self, MmsError* mmsError
bool specWithResult) bool specWithResult)
{ {
MmsValue* value = NULL; MmsValue* value = NULL;
MmsError err = MMS_ERROR_NONE;
Semaphore waitForResponse = Semaphore_create(1); struct readNVParameters parameter;
Semaphore_wait(waitForResponse);
struct threeParameters parameter;
MmsError respErr = MMS_ERROR_NONE; parameter.sem = Semaphore_create(1);;
parameter.value = NULL;
parameter.err = MMS_ERROR_NONE;
parameter.param1 = waitForResponse; Semaphore_wait(parameter.sem);
parameter.param2 = NULL;
parameter.param3 = &respErr;
MmsConnection_readNamedVariableListValuesAsync(self, &respErr, domainId, listName, specWithResult, MmsConnection_readNamedVariableListValuesAsync(self, &err, domainId, listName, specWithResult,
readVariableHandler, &parameter); readVariableHandler, &parameter);
if (respErr == MMS_ERROR_NONE) { if (err == MMS_ERROR_NONE) {
Semaphore_wait(waitForResponse); Semaphore_wait(parameter.sem);
value = (MmsValue*) parameter.param2; value = parameter.value;
err = parameter.err;
} }
Semaphore_destroy(waitForResponse); Semaphore_destroy(parameter.sem);
if (mmsError) if (mmsError)
*mmsError = respErr; *mmsError = err;
return value; return value;
} }
@ -2080,7 +2113,7 @@ MmsConnection_readNamedVariableListValuesAsync(MmsConnection self, MmsError* mms
mmsClient_createReadNamedVariableListRequest(invokeId, domainId, listName, mmsClient_createReadNamedVariableListRequest(invokeId, domainId, listName,
payload, specWithResult); payload, specWithResult);
MmsError err = sendAsyncRequest(self, invokeId, payload, MMS_CALL_TYPE_READ_VARIABLE, handler, parameter); MmsError err = sendAsyncRequest(self, invokeId, payload, MMS_CALL_TYPE_READ_MULTIPLE_VARIABLES, handler, parameter);
if (mmsError) if (mmsError)
*mmsError = err; *mmsError = err;
@ -2096,33 +2129,32 @@ MmsConnection_readNamedVariableListValuesAssociationSpecific(
const char* listName, const char* listName,
bool specWithResult) bool specWithResult)
{ {
MmsValue* value = NULL;
Semaphore waitForResponse = Semaphore_create(1);
Semaphore_wait(waitForResponse); MmsValue* value = NULL;
MmsError err = MMS_ERROR_NONE;
struct threeParameters parameter; struct readNVParameters parameter;
MmsError respErr = MMS_ERROR_NONE; parameter.sem = Semaphore_create(1);;
parameter.value = NULL;
parameter.err = MMS_ERROR_NONE;
parameter.param1 = waitForResponse; Semaphore_wait(parameter.sem);
parameter.param2 = NULL;
parameter.param3 = &respErr;
MmsConnection_readNamedVariableListValuesAssociationSpecificAsync(self, &respErr, listName, specWithResult, MmsConnection_readNamedVariableListValuesAssociationSpecificAsync(self, &err, listName, specWithResult,
readVariableHandler, &parameter); readVariableHandler, &parameter);
if (respErr == MMS_ERROR_NONE) { if (err == MMS_ERROR_NONE) {
Semaphore_wait(waitForResponse); Semaphore_wait(parameter.sem);
value = (MmsValue*) parameter.param2; value = parameter.value;
err = parameter.err;
} }
Semaphore_destroy(waitForResponse); Semaphore_destroy(parameter.sem);
if (mmsError) if (mmsError)
*mmsError = respErr; *mmsError = err;
return value; return value;
} }
@ -2147,7 +2179,7 @@ MmsConnection_readNamedVariableListValuesAssociationSpecificAsync(MmsConnection
mmsClient_createReadAssociationSpecificNamedVariableListRequest(invokeId, listName, mmsClient_createReadAssociationSpecificNamedVariableListRequest(invokeId, listName,
payload, specWithResult); payload, specWithResult);
MmsError err = sendAsyncRequest(self, invokeId, payload, MMS_CALL_TYPE_READ_VARIABLE, handler, parameter); MmsError err = sendAsyncRequest(self, invokeId, payload, MMS_CALL_TYPE_READ_MULTIPLE_VARIABLES, handler, parameter);
if (mmsError) if (mmsError)
*mmsError = err; *mmsError = err;
@ -2307,32 +2339,50 @@ exit_function:
return invokeId; return invokeId;
} }
struct defineNVLParameters
{
Semaphore waitForResponse;
MmsError err;
bool success;
};
static void
defineNVLHandler(int invokeId, void* parameter, MmsError mmsError, bool success)
{
struct defineNVLParameters* parameters = (struct defineNVLParameters*) parameter;
parameters->err = mmsError;
parameters->success = success;
/* unblock user thread */
Semaphore_post(parameters->waitForResponse);
}
void void
MmsConnection_defineNamedVariableList(MmsConnection self, MmsError* mmsError, MmsConnection_defineNamedVariableList(MmsConnection self, MmsError* mmsError,
const char* domainId, const char* listName, LinkedList variableSpecs) const char* domainId, const char* listName, LinkedList variableSpecs)
{ {
if (getAssociationState(self) != MMS_STATE_CONNECTED) { struct defineNVLParameters parameter;
*mmsError = MMS_ERROR_CONNECTION_LOST;
goto exit_function;
}
ByteBuffer* payload = IsoClientConnection_allocateTransmitBuffer(self->isoClient); MmsError err;
uint32_t invokeId = getNextInvokeId(self); parameter.waitForResponse = Semaphore_create(1);
mmsClient_createDefineNamedVariableListRequest(invokeId, payload, domainId, Semaphore_wait(parameter.waitForResponse);
listName, variableSpecs, false);
ByteBuffer* responseMessage = sendRequestAndWaitForResponse(self, invokeId, payload, mmsError); MmsConnection_defineNamedVariableListAsync(self, &err, domainId, listName, variableSpecs,
defineNVLHandler, &parameter);
if (responseMessage != NULL) if (err == MMS_ERROR_NONE) {
if (!mmsClient_parseDefineNamedVariableResponse(self->lastResponse, NULL)) Semaphore_wait(parameter.waitForResponse);
*mmsError = MMS_ERROR_PARSING_RESPONSE; err = parameter.err;
}
releaseResponse(self); Semaphore_destroy(parameter.waitForResponse);
exit_function: if (mmsError)
return; *mmsError = err;
} }
uint32_t uint32_t
@ -2369,28 +2419,26 @@ void
MmsConnection_defineNamedVariableListAssociationSpecific(MmsConnection self, MmsConnection_defineNamedVariableListAssociationSpecific(MmsConnection self,
MmsError* mmsError, const char* listName, LinkedList variableSpecs) MmsError* mmsError, const char* listName, LinkedList variableSpecs)
{ {
if (getAssociationState(self) != MMS_STATE_CONNECTED) { struct defineNVLParameters parameter;
*mmsError = MMS_ERROR_CONNECTION_LOST;
goto exit_function;
}
ByteBuffer* payload = IsoClientConnection_allocateTransmitBuffer(self->isoClient); MmsError err;
uint32_t invokeId = getNextInvokeId(self); parameter.waitForResponse = Semaphore_create(1);
mmsClient_createDefineNamedVariableListRequest(invokeId, payload, NULL, Semaphore_wait(parameter.waitForResponse);
listName, variableSpecs, true);
ByteBuffer* responseMessage = sendRequestAndWaitForResponse(self, invokeId, payload, mmsError); MmsConnection_defineNamedVariableListAssociationSpecificAsync(self, &err, listName, variableSpecs,
defineNVLHandler, &parameter);
if (responseMessage != NULL) if (err == MMS_ERROR_NONE) {
if (!mmsClient_parseDefineNamedVariableResponse(self->lastResponse, NULL)) Semaphore_wait(parameter.waitForResponse);
*mmsError = MMS_ERROR_PARSING_RESPONSE; err = parameter.err;
}
releaseResponse(self); Semaphore_destroy(parameter.waitForResponse);
exit_function: if (mmsError)
return; *mmsError = err;
} }
uint32_t uint32_t
@ -2411,7 +2459,7 @@ MmsConnection_defineNamedVariableListAssociationSpecificAsync(MmsConnection self
invokeId = getNextInvokeId(self); invokeId = getNextInvokeId(self);
mmsClient_createDefineNamedVariableListRequest(invokeId, payload, NULL, mmsClient_createDefineNamedVariableListRequest(invokeId, payload, NULL,
listName, variableSpecs, false); listName, variableSpecs, true);
MmsError err = sendAsyncRequest(self, invokeId, payload, MMS_CALL_TYPE_DEFINE_NVL, handler, parameter); MmsError err = sendAsyncRequest(self, invokeId, payload, MMS_CALL_TYPE_DEFINE_NVL, handler, parameter);
@ -2429,27 +2477,55 @@ MmsConnection_deleteNamedVariableList(MmsConnection self, MmsError* mmsError,
{ {
bool isDeleted = false; bool isDeleted = false;
struct defineNVLParameters parameter;
MmsError err;
parameter.waitForResponse = Semaphore_create(1);
Semaphore_wait(parameter.waitForResponse);
MmsConnection_deleteNamedVariableListAsync(self, &err, domainId, listName, defineNVLHandler, &parameter);
if (err == MMS_ERROR_NONE) {
Semaphore_wait(parameter.waitForResponse);
err = parameter.err;
isDeleted = parameter.success;
}
Semaphore_destroy(parameter.waitForResponse);
if (mmsError)
*mmsError = err;
return isDeleted;
}
uint32_t
MmsConnection_deleteNamedVariableListAsync(MmsConnection self, MmsError* mmsError, const char* domainId, const char* listName,
MmsConnection_GenericServiceHandler handler, void* parameter)
{
uint32_t invokeId = 0;
if (getAssociationState(self) != MMS_STATE_CONNECTED) { if (getAssociationState(self) != MMS_STATE_CONNECTED) {
if (mmsError)
*mmsError = MMS_ERROR_CONNECTION_LOST; *mmsError = MMS_ERROR_CONNECTION_LOST;
goto exit_function; goto exit_function;
} }
ByteBuffer* payload = IsoClientConnection_allocateTransmitBuffer(self->isoClient); ByteBuffer* payload = IsoClientConnection_allocateTransmitBuffer(self->isoClient);
uint32_t invokeId = getNextInvokeId(self); invokeId = getNextInvokeId(self);
mmsClient_createDeleteNamedVariableListRequest(invokeId, payload, domainId, listName); mmsClient_createDeleteNamedVariableListRequest(invokeId, payload, domainId, listName);
ByteBuffer* responseMessage = sendRequestAndWaitForResponse(self, invokeId, payload, mmsError); MmsError err = sendAsyncRequest(self, invokeId, payload, MMS_CALL_TYPE_DELETE_NVL, handler, parameter);
if (responseMessage != NULL) if (mmsError)
if (mmsClient_parseDeleteNamedVariableListResponse(self->lastResponse, NULL)) *mmsError = err;
isDeleted = true;
releaseResponse(self);
exit_function: exit_function:
return isDeleted; return invokeId;
} }
bool bool
@ -2458,28 +2534,75 @@ MmsConnection_deleteAssociationSpecificNamedVariableList(MmsConnection self,
{ {
bool isDeleted = false; bool isDeleted = false;
struct defineNVLParameters parameter;
MmsError err;
parameter.waitForResponse = Semaphore_create(1);
Semaphore_wait(parameter.waitForResponse);
MmsConnection_deleteAssociationSpecificNamedVariableListAsync(self, &err, listName, defineNVLHandler, &parameter);
if (err == MMS_ERROR_NONE) {
Semaphore_wait(parameter.waitForResponse);
err = parameter.err;
isDeleted = parameter.success;
}
Semaphore_destroy(parameter.waitForResponse);
if (mmsError)
*mmsError = err;
return isDeleted;
}
uint32_t
MmsConnection_deleteAssociationSpecificNamedVariableListAsync(MmsConnection self, MmsError* mmsError, const char* listName,
MmsConnection_GenericServiceHandler handler, void* parameter)
{
uint32_t invokeId = 0;
if (getAssociationState(self) != MMS_STATE_CONNECTED) { if (getAssociationState(self) != MMS_STATE_CONNECTED) {
if (mmsError)
*mmsError = MMS_ERROR_CONNECTION_LOST; *mmsError = MMS_ERROR_CONNECTION_LOST;
goto exit_function; goto exit_function;
} }
ByteBuffer* payload = IsoClientConnection_allocateTransmitBuffer(self->isoClient); ByteBuffer* payload = IsoClientConnection_allocateTransmitBuffer(self->isoClient);
uint32_t invokeId = getNextInvokeId(self); invokeId = getNextInvokeId(self);
mmsClient_createDeleteAssociationSpecificNamedVariableListRequest( mmsClient_createDeleteAssociationSpecificNamedVariableListRequest(
invokeId, payload, listName); invokeId, payload, listName);
ByteBuffer* responseMessage = sendRequestAndWaitForResponse(self, invokeId, payload, mmsError); MmsError err = sendAsyncRequest(self, invokeId, payload, MMS_CALL_TYPE_DELETE_NVL, handler, parameter);
if (responseMessage != NULL)
if (mmsClient_parseDeleteNamedVariableListResponse(self->lastResponse, NULL))
isDeleted = true;
releaseResponse(self); if (mmsError)
*mmsError = err;
exit_function: exit_function:
return isDeleted; return invokeId;
}
struct getVarAccessAttrParameters
{
Semaphore waitForResponse;
MmsError err;
MmsVariableSpecification* typeSpec;
};
static void
getAccessAttrHandler(int invokeId, void* parameter, MmsError mmsError, MmsVariableSpecification* typeSpec)
{
struct getVarAccessAttrParameters* parameters = (struct getVarAccessAttrParameters*) parameter;
parameters->err = mmsError;
parameters->typeSpec = typeSpec;
/* unblock user thread */
Semaphore_post(parameters->waitForResponse);
} }
MmsVariableSpecification* MmsVariableSpecification*
@ -2488,26 +2611,56 @@ MmsConnection_getVariableAccessAttributes(MmsConnection self, MmsError* mmsError
{ {
MmsVariableSpecification* typeSpec = NULL; MmsVariableSpecification* typeSpec = NULL;
struct getVarAccessAttrParameters parameter;
MmsError err;
parameter.waitForResponse = Semaphore_create(1);
Semaphore_wait(parameter.waitForResponse);
MmsConnection_getVariableAccessAttributesAsync(self, &err, domainId, itemId, getAccessAttrHandler, &parameter);
if (err == MMS_ERROR_NONE) {
Semaphore_wait(parameter.waitForResponse);
err = parameter.err;
typeSpec = parameter.typeSpec;
}
Semaphore_destroy(parameter.waitForResponse);
if (mmsError)
*mmsError = err;
return typeSpec;
}
uint32_t
MmsConnection_getVariableAccessAttributesAsync(MmsConnection self, MmsError* mmsError,
const char* domainId, const char* itemId,
MmsConnection_GetVariableAccessAttributesHandler handler, void* parameter)
{
uint32_t invokeId = 0;
if (getAssociationState(self) != MMS_STATE_CONNECTED) { if (getAssociationState(self) != MMS_STATE_CONNECTED) {
if (mmsError)
*mmsError = MMS_ERROR_CONNECTION_LOST; *mmsError = MMS_ERROR_CONNECTION_LOST;
goto exit_function; goto exit_function;
} }
ByteBuffer* payload = IsoClientConnection_allocateTransmitBuffer(self->isoClient); ByteBuffer* payload = IsoClientConnection_allocateTransmitBuffer(self->isoClient);
uint32_t invokeId = getNextInvokeId(self); invokeId = getNextInvokeId(self);
mmsClient_createGetVariableAccessAttributesRequest(invokeId, domainId, itemId, payload); mmsClient_createGetVariableAccessAttributesRequest(invokeId, domainId, itemId, payload);
ByteBuffer* responseMessage = sendRequestAndWaitForResponse(self, invokeId, payload, mmsError); MmsError err = sendAsyncRequest(self, invokeId, payload, MMS_CALL_TYPE_GET_VAR_ACCESS_ATTR, handler, parameter);
if (responseMessage != NULL)
typeSpec = mmsClient_parseGetVariableAccessAttributesResponse(self->lastResponse, NULL);
releaseResponse(self); if (mmsError)
*mmsError = err;
exit_function: exit_function:
return typeSpec; return invokeId;
} }
MmsServerIdentity* MmsServerIdentity*
@ -2915,47 +3068,23 @@ exit_function:
return invokeId; return invokeId;
} }
#if 0 struct writeMultipleVariablesParameter
void
MmsConnection_writeMultipleVariables(MmsConnection self, MmsError* mmsError, const char* domainId,
LinkedList /*<char*>*/items,
LinkedList /* <MmsValue*> */values,
/* OUTPUT */LinkedList* /* <MmsValue*> */accessResults)
{ {
uint32_t invokeId = getNextInvokeId(self); Semaphore sem;
MmsError err;
ByteBuffer* payload = IsoClientConnection_allocateTransmitBuffer(self->isoClient); LinkedList result;
};
mmsClient_createWriteMultipleItemsRequest(invokeId, domainId, items, values, payload);
ByteBuffer* responseMessage = sendRequestAndWaitForResponse(self, invokeId, payload, mmsError);
if (responseMessage != NULL) {
int numberOfItems = LinkedList_size(items);
mmsClient_parseWriteMultipleItemsResponse(self->lastResponse, self->lastResponseBufPos, mmsError,
numberOfItems, accessResults);
}
releaseResponse(self);
}
#endif
static void static void
writeMultipleVariablesHandler(int invokeId, void* parameter, MmsError mmsError, LinkedList /* <MmsValue*> */ accessResults) writeMultipleVariablesHandler(int invokeId, void* parameter, MmsError mmsError, LinkedList /* <MmsValue*> */ accessResults)
{ {
struct threeParameters* parameters = (struct threeParameters*) parameter; struct writeMultipleVariablesParameter* parameters = (struct writeMultipleVariablesParameter*) parameter;
Semaphore waitForResponse = (Semaphore) parameters->param1;
MmsError* err = (MmsError*) parameters->param3;
parameters->param2 = accessResults; parameters->err = mmsError;
parameters->result = accessResults;
*err = mmsError;
/* unblock user thread */ /* unblock user thread */
Semaphore_post(waitForResponse); Semaphore_post(parameters->sem);
} }
void void
@ -2964,36 +3093,34 @@ MmsConnection_writeMultipleVariables(MmsConnection self, MmsError* mmsError, con
LinkedList /* <MmsValue*> */values, LinkedList /* <MmsValue*> */values,
/* OUTPUT */LinkedList* /* <MmsValue*> */accessResults) /* OUTPUT */LinkedList* /* <MmsValue*> */accessResults)
{ {
Semaphore waitForResponse = Semaphore_create(1); MmsError err = MMS_ERROR_NONE;
Semaphore_wait(waitForResponse);
struct threeParameters parameter; struct writeMultipleVariablesParameter parameter;
MmsError respErr = MMS_ERROR_NONE; parameter.sem = Semaphore_create(1);;
parameter.err = MMS_ERROR_NONE;
parameter.result = NULL;
parameter.param1 = waitForResponse; Semaphore_wait(parameter.sem);
parameter.param2 = NULL;
parameter.param3 = &respErr;
MmsConnection_writeMultipleVariablesAsync(self, &respErr, domainId, items, values, writeMultipleVariablesHandler, &parameter); MmsConnection_writeMultipleVariablesAsync(self, &err, domainId, items, values, writeMultipleVariablesHandler, &parameter);
if (respErr == MMS_ERROR_NONE) { if (err == MMS_ERROR_NONE) {
Semaphore_wait(waitForResponse); Semaphore_wait(parameter.sem);
*accessResults = (LinkedList) parameter.param2; err = parameter.err;
*accessResults = parameter.result;
} }
else else
*accessResults = NULL; *accessResults = NULL;
if (mmsError) if (mmsError)
*mmsError = respErr; *mmsError = err;
Semaphore_destroy(waitForResponse); Semaphore_destroy(parameter.sem);
} }
uint32_t uint32_t
MmsConnection_writeMultipleVariablesAsync(MmsConnection self, MmsError* mmsError, const char* domainId, MmsConnection_writeMultipleVariablesAsync(MmsConnection self, MmsError* mmsError, const char* domainId,
LinkedList /*<char*>*/ items, LinkedList /* <MmsValue*> */ values, LinkedList /*<char*>*/ items, LinkedList /* <MmsValue*> */ values,

Write Preview
Loading…
Cancel
Save