//--------------------------------------------------------------------------------------------------
static void List
(
void
)
//--------------------------------------------------------------------------------------------------
{
le_msg_MessageRef_t msgRef = le_msg_CreateMsg(SessionRef);
le_msg_SetFd(msgRef, 1);
le_sdtp_Msg_t* msgPtr = le_msg_GetPayloadPtr(msgRef);
msgPtr->msgType = LE_SDTP_MSGID_LIST;
msgRef = le_msg_RequestSyncResponse(msgRef);
if (msgRef == NULL)
{
ExitWithErrorMsg("Communication with Service Directory failed.");
}
le_msg_ReleaseMsg(msgRef);
exit(EXIT_SUCCESS);
}
//--------------------------------------------------------------------------------------------------
void RemoveBugTest
(
BugTestRef_t addHandlerRef
///< [IN]
)
{
le_msg_MessageRef_t _msgRef;
le_msg_MessageRef_t _responseMsgRef;
_Message_t* _msgPtr;
// Will not be used if no data is sent/received from server.
__attribute__((unused)) uint8_t* _msgBufPtr;
// Range check values, if appropriate
// Create a new message object and get the message buffer
_msgRef = le_msg_CreateMsg(GetCurrentSessionRef());
_msgPtr = le_msg_GetPayloadPtr(_msgRef);
_msgPtr->id = _MSGID_RemoveBugTest;
_msgBufPtr = _msgPtr->buffer;
// Pack the input parameters
// The passed in handlerRef is a safe reference for the client data object. Need to get the
// real handlerRef from the client data object and then delete both the safe reference and
// the object since they are no longer needed.
_LOCK
_ClientData_t* clientDataPtr = le_ref_Lookup(_HandlerRefMap, addHandlerRef);
le_ref_DeleteRef(_HandlerRefMap, addHandlerRef);
_UNLOCK
addHandlerRef = (BugTestRef_t)clientDataPtr->handlerRef;
le_mem_Release(clientDataPtr);
_msgBufPtr = PackData( _msgBufPtr, &addHandlerRef, sizeof(BugTestRef_t) );
// Send a request to the server and get the response.
LE_DEBUG("Sending message to server and waiting for response");
_responseMsgRef = le_msg_RequestSyncResponse(_msgRef);
// It is a serious error if we don't get a valid response from the server
LE_FATAL_IF(_responseMsgRef == NULL, "Valid response was not received from server");
// Process the result and/or output parameters, if there are any.
_msgPtr = le_msg_GetPayloadPtr(_responseMsgRef);
_msgBufPtr = _msgPtr->buffer;
// Unpack any "out" parameters
// Release the message object, now that all results/output has been copied.
le_msg_ReleaseMsg(_responseMsgRef);
}
//--------------------------------------------------------------------------------------------------
void TriggerTestA
(
void
)
{
le_msg_MessageRef_t _msgRef;
le_msg_MessageRef_t _responseMsgRef;
_Message_t* _msgPtr;
// Will not be used if no data is sent/received from server.
__attribute__((unused)) uint8_t* _msgBufPtr;
// Range check values, if appropriate
// Create a new message object and get the message buffer
_msgRef = le_msg_CreateMsg(GetCurrentSessionRef());
_msgPtr = le_msg_GetPayloadPtr(_msgRef);
_msgPtr->id = _MSGID_TriggerTestA;
_msgBufPtr = _msgPtr->buffer;
// Pack the input parameters
// Send a request to the server and get the response.
LE_DEBUG("Sending message to server and waiting for response");
_responseMsgRef = le_msg_RequestSyncResponse(_msgRef);
// It is a serious error if we don't get a valid response from the server
LE_FATAL_IF(_responseMsgRef == NULL, "Valid response was not received from server");
// Process the result and/or output parameters, if there are any.
_msgPtr = le_msg_GetPayloadPtr(_responseMsgRef);
_msgBufPtr = _msgPtr->buffer;
// Unpack any "out" parameters
// Release the message object, now that all results/output has been copied.
le_msg_ReleaseMsg(_responseMsgRef);
}
//--------------------------------------------------------------------------------------------------
static void SendUnbindAllRequest
(
void
)
//--------------------------------------------------------------------------------------------------
{
le_msg_MessageRef_t msgRef = le_msg_CreateMsg(SessionRef);
le_sdtp_Msg_t* msgPtr = le_msg_GetPayloadPtr(msgRef);
msgPtr->msgType = LE_SDTP_MSGID_UNBIND_ALL;
msgRef = le_msg_RequestSyncResponse(msgRef);
if (msgRef == NULL)
{
ExitWithErrorMsg("Communication with Service Directory failed.");
}
le_msg_ReleaseMsg(msgRef);
}
//--------------------------------------------------------------------------------------------------
static void SendBindRequest
(
uid_t uid, ///< [in] Unix user ID of the client whose binding is being created.
le_cfg_IteratorRef_t i ///< [in] Configuration read iterator.
)
//--------------------------------------------------------------------------------------------------
{
le_result_t result;
le_msg_MessageRef_t msgRef = le_msg_CreateMsg(SessionRef);
le_sdtp_Msg_t* msgPtr = le_msg_GetPayloadPtr(msgRef);
msgPtr->msgType = LE_SDTP_MSGID_BIND;
msgPtr->client = uid;
// Fetch the client's service name.
result = le_cfg_GetNodeName(i,
"",
msgPtr->clientServiceName,
sizeof(msgPtr->clientServiceName));
if (result != LE_OK)
{
char path[LIMIT_MAX_PATH_BYTES];
le_cfg_GetPath(i, "", path, sizeof(path));
LE_CRIT("Configured client service name too long (@ %s)", path);
return;
}
// Fetch the server's user ID.
result = GetServerUid(i, &msgPtr->server);
if (result != LE_OK)
{
return;
}
// Fetch the server's service name.
result = le_cfg_GetString(i,
"interface",
msgPtr->serverServiceName,
sizeof(msgPtr->serverServiceName),
"");
if (result != LE_OK)
{
char path[LIMIT_MAX_PATH_BYTES];
le_cfg_GetPath(i, "interface", path, sizeof(path));
LE_CRIT("Server interface name too big (@ %s)", path);
return;
}
if (msgPtr->serverServiceName[0] == '\0')
{
char path[LIMIT_MAX_PATH_BYTES];
le_cfg_GetPath(i, "interface", path, sizeof(path));
LE_CRIT("Server interface name missing (@ %s)", path);
return;
}
msgRef = le_msg_RequestSyncResponse(msgRef);
if (msgRef == NULL)
{
ExitWithErrorMsg("Communication with Service Directory failed.");
}
le_msg_ReleaseMsg(msgRef);
}
//--------------------------------------------------------------------------------------------------
BugTestRef_t AddBugTest
(
const char* newPathPtr,
///< [IN]
BugTestFunc_t handlerPtr,
///< [IN]
void* contextPtr
///< [IN]
)
{
le_msg_MessageRef_t _msgRef;
le_msg_MessageRef_t _responseMsgRef;
_Message_t* _msgPtr;
// Will not be used if no data is sent/received from server.
__attribute__((unused)) uint8_t* _msgBufPtr;
BugTestRef_t _result;
// Range check values, if appropriate
if ( strlen(newPathPtr) > 512 ) LE_FATAL("strlen(newPathPtr) > 512");
// Create a new message object and get the message buffer
_msgRef = le_msg_CreateMsg(GetCurrentSessionRef());
_msgPtr = le_msg_GetPayloadPtr(_msgRef);
_msgPtr->id = _MSGID_AddBugTest;
_msgBufPtr = _msgPtr->buffer;
// Pack the input parameters
_msgBufPtr = PackString( _msgBufPtr, newPathPtr );
// The input parameters are stored in the client data object, and it is
// a pointer to this object that is passed down.
// Create a new client data object and fill it in
_ClientData_t* _clientDataPtr = le_mem_ForceAlloc(_ClientDataPool);
_clientDataPtr->handlerPtr = (le_event_HandlerFunc_t)handlerPtr;
_clientDataPtr->contextPtr = contextPtr;
_clientDataPtr->callersThreadRef = le_thread_GetCurrent();
contextPtr = _clientDataPtr;
_msgBufPtr = PackData( _msgBufPtr, &contextPtr, sizeof(void*) );
// Send a request to the server and get the response.
LE_DEBUG("Sending message to server and waiting for response");
_responseMsgRef = le_msg_RequestSyncResponse(_msgRef);
// It is a serious error if we don't get a valid response from the server
LE_FATAL_IF(_responseMsgRef == NULL, "Valid response was not received from server");
// Process the result and/or output parameters, if there are any.
_msgPtr = le_msg_GetPayloadPtr(_responseMsgRef);
_msgBufPtr = _msgPtr->buffer;
// Unpack the result first
_msgBufPtr = UnpackData( _msgBufPtr, &_result, sizeof(_result) );
// Put the handler reference result into the client data object, and
// then return a safe reference to the client data object as the reference.
_clientDataPtr->handlerRef = (le_event_HandlerRef_t)_result;
_LOCK
_result = le_ref_CreateRef(_HandlerRefMap, _clientDataPtr);
_UNLOCK
// Unpack any "out" parameters
// Release the message object, now that all results/output has been copied.
le_msg_ReleaseMsg(_responseMsgRef);
return _result;
}
//--------------------------------------------------------------------------------------------------
void allParameters
(
common_EnumExample_t a,
///< [IN]
///< first one-line comment
///< second one-line comment
uint32_t* bPtr,
///< [OUT]
const uint32_t* dataPtr,
///< [IN]
size_t dataNumElements,
///< [IN]
uint32_t* outputPtr,
///< [OUT]
///< some more comments here
///< and some comments here as well
size_t* outputNumElementsPtr,
///< [INOUT]
const char* label,
///< [IN]
char* response,
///< [OUT]
///< comments on final parameter, first line
///< and more comments
size_t responseNumElements,
///< [IN]
char* more,
///< [OUT]
///< This parameter tests a bug fix
size_t moreNumElements
///< [IN]
)
{
le_msg_MessageRef_t _msgRef;
le_msg_MessageRef_t _responseMsgRef;
_Message_t* _msgPtr;
// Will not be used if no data is sent/received from server.
__attribute__((unused)) uint8_t* _msgBufPtr;
// Range check values, if appropriate
if ( dataNumElements > 10 ) LE_FATAL("dataNumElements > 10");
if ( strlen(label) > 20 ) LE_FATAL("strlen(label) > 20");
// Create a new message object and get the message buffer
_msgRef = le_msg_CreateMsg(GetCurrentSessionRef());
_msgPtr = le_msg_GetPayloadPtr(_msgRef);
_msgPtr->id = _MSGID_allParameters;
_msgBufPtr = _msgPtr->buffer;
// Pack the input parameters
_msgBufPtr = PackData( _msgBufPtr, &a, sizeof(common_EnumExample_t) );
_msgBufPtr = PackData( _msgBufPtr, &dataNumElements, sizeof(size_t) );
_msgBufPtr = PackData( _msgBufPtr, dataPtr, dataNumElements*sizeof(uint32_t) );
_msgBufPtr = PackData( _msgBufPtr, outputNumElementsPtr, sizeof(size_t) );
_msgBufPtr = PackString( _msgBufPtr, label );
_msgBufPtr = PackData( _msgBufPtr, &responseNumElements, sizeof(size_t) );
_msgBufPtr = PackData( _msgBufPtr, &moreNumElements, sizeof(size_t) );
// Send a request to the server and get the response.
LE_DEBUG("Sending message to server and waiting for response");
_responseMsgRef = le_msg_RequestSyncResponse(_msgRef);
// It is a serious error if we don't get a valid response from the server
LE_FATAL_IF(_responseMsgRef == NULL, "Valid response was not received from server");
// Process the result and/or output parameters, if there are any.
_msgPtr = le_msg_GetPayloadPtr(_responseMsgRef);
_msgBufPtr = _msgPtr->buffer;
// Unpack any "out" parameters
_msgBufPtr = UnpackData( _msgBufPtr, bPtr, sizeof(uint32_t) );
_msgBufPtr = UnpackData( _msgBufPtr, outputNumElementsPtr, sizeof(size_t) );
_msgBufPtr = UnpackData( _msgBufPtr, outputPtr, *outputNumElementsPtr*sizeof(uint32_t) );
_msgBufPtr = UnpackDataString( _msgBufPtr, response, responseNumElements*sizeof(char) );
_msgBufPtr = UnpackDataString( _msgBufPtr, more, moreNumElements*sizeof(char) );
// Release the message object, now that all results/output has been copied.
le_msg_ReleaseMsg(_responseMsgRef);
}
