AJ_Status AJ_PeerAuthenticate(AJ_BusAttachment* bus, const char* peerName, AJ_PeerAuthenticateCallback callback, void* cbContext)
{
AJ_Message msg;
char guidStr[33];
AJ_GUID localGuid;
uint32_t version = REQUIRED_AUTH_VERSION;
/*
* Check there isn't an authentication in progress
*/
if (authContext.callback || authContext.peerGuid) {
/*
* The existing authentication may have timed-out
*/
if (AJ_GetElapsedTime(&authContext.timer, TRUE) < MAX_AUTH_TIME) {
return AJ_ERR_RESOURCES;
}
/*
* Report the failed authentication
*/
PeerAuthComplete(AJ_ERR_TIMEOUT);
}
authContext.callback = callback;
authContext.cbContext = cbContext;
authContext.peerName = peerName;
AJ_InitTimer(&authContext.timer);
/*
* Kick off autnetication with an ExchangeGUIDS method call
*/
AJ_MarshalMethodCall(bus, &msg, AJ_METHOD_EXCHANGE_GUIDS, peerName, 0, AJ_NO_FLAGS, CALL_TIMEOUT);
AJ_GetLocalGUID(&localGuid);
AJ_GUID_ToString(&localGuid, guidStr, sizeof(guidStr));
AJ_MarshalArgs(&msg, "su", guidStr, version);
return AJ_DeliverMsg(&msg);
}
static void InitMandatoryPropertiesInRAM()
{
char* machineIdValue = propertyStoreRuntimeValues[AJSVC_PROPERTY_STORE_APP_ID].value[AJSVC_PROPERTY_STORE_NO_LANGUAGE_INDEX];
const char* currentAppIdValue = AJSVC_PropertyStore_GetValue(AJSVC_PROPERTY_STORE_APP_ID);
const char* currentDeviceIdValue = AJSVC_PropertyStore_GetValue(AJSVC_PROPERTY_STORE_DEVICE_ID);
const char* currentDeviceNameValue = AJSVC_PropertyStore_GetValue(AJSVC_PROPERTY_STORE_DEVICE_NAME);
size_t serialIdLen = 0;
size_t machineIdLen = 0;
AJ_GUID theAJ_GUID;
AJ_Status status;
char deviceName[DEVICE_NAME_VALUE_LENGTH + 1] = { 0 };
if (currentAppIdValue == NULL || currentAppIdValue[0] == '\0') {
status = AJ_GetLocalGUID(&theAJ_GUID);
if (status == AJ_OK) {
AJ_GUID_ToString(&theAJ_GUID, machineIdValue, propertyStoreRuntimeValues[AJSVC_PROPERTY_STORE_APP_ID].size);
}
}
if (currentDeviceIdValue == NULL || currentDeviceIdValue[0] == '\0') {
AJSVC_PropertyStore_SetValue(AJSVC_PROPERTY_STORE_DEVICE_ID, machineIdValue);
}
if (currentDeviceNameValue == NULL || currentDeviceNameValue[0] == '\0') {
#ifdef ONBOARDING_SERVICE
serialIdLen = AJOBS_DEVICE_SERIAL_ID_LEN;
#else
serialIdLen = 7;
#endif
machineIdLen = strlen(machineIdValue);
#ifdef _WIN32
_snprintf(deviceName, DEVICE_NAME_VALUE_LENGTH + 1, "%s %s %s", deviceManufactureName, deviceProductName, &machineIdValue[machineIdLen - min(serialIdLen, machineIdLen)]);
#else
snprintf(deviceName, DEVICE_NAME_VALUE_LENGTH + 1, "%s %s %s", deviceManufactureName, deviceProductName, &machineIdValue[machineIdLen - min(serialIdLen, machineIdLen)]);
#endif
AJSVC_PropertyStore_SetValue(AJSVC_PROPERTY_STORE_DEVICE_NAME, deviceName);
}
}
static AJ_Status AnonymousAuthAdvance(AJ_IOBuffer* rxBuf, AJ_IOBuffer* txBuf)
{
AJ_Status status = AJ_OK;
AJ_GUID localGuid;
char buf[40];
uint32_t ret;
//initiate the SASL exchange with AUTH ANONYMOUS
status = WriteLine(txBuf, "AUTH ANONYMOUS\n");
// ResetRead(rxBuf);
if (status == AJ_OK)
{
// expect server to send back OK GUID
status = ReadLine(rxBuf);
if (status == AJ_OK)
{
if (memcmp(rxBuf->readPtr, "OK", 2) != 0)
{
return AJ_ERR_ACCESS_ROUTING_NODE;
}
}
}
if (status == AJ_OK)
{
status = WriteLine(txBuf, "INFORM_PROTO_VERSION 10\n");
// ResetRead(rxBuf);
}
if (status == AJ_OK)
{
// expect server to send back INFORM_PROTO_VERSION version#
status = ReadLine(rxBuf);
if (status == AJ_OK)
{
if (memcmp(rxBuf->readPtr, "INFORM_PROTO_VERSION", strlen("INFORM_PROTO_VERSION")) != 0)
{
return AJ_ERR_ACCESS_ROUTING_NODE;
}
routingProtoVersion = atoi((const char*)(rxBuf->readPtr + strlen("INFORM_PROTO_VERSION") + 1));
if (routingProtoVersion < AJ_GetMinProtoVersion())
{
AJ_InfoPrintf(("ERR_OLD_VERSION: Found version %u but minimum %u required", routingProtoVersion, AJ_GetMinProtoVersion()));
return AJ_ERR_OLD_VERSION;
}
}
}
if (status == AJ_OK)
{
//send BEGIN LocalGUID to server
AJ_GetLocalGUID(&localGuid);
strcpy(buf, "BEGIN ");
status = AJ_GUID_ToString(&localGuid, buf + strlen(buf), 33);
strcat(buf, "\n");
status = WriteLine(txBuf, buf);
ResetRead(rxBuf);
}
return status;
}
static AJ_Status HandleGetMachineId(AJ_Message* msg, AJ_Message* reply)
{
char guidStr[33];
AJ_GUID localGuid;
AJ_InfoPrintf(("HandleGetMachineId(msg=0x%p, reply=0x%p)\n", msg, reply));
AJ_MarshalReplyMsg(msg, reply);
AJ_GetLocalGUID(&localGuid);
AJ_GUID_ToString(&localGuid, guidStr, sizeof(guidStr));
return AJ_MarshalArgs(reply, "s", guidStr);
}
static AJ_Status GenSessionKey(AJ_Message* msg)
{
AJ_Message call;
if (authContext.sasl.mechanism) {
authContext.sasl.mechanism->Final(authContext.peerGuid);
}
authContext.sasl.state = AJ_SASL_IDLE;
AJ_MarshalMethodCall(msg->bus, &call, AJ_METHOD_GEN_SESSION_KEY, msg->sender, 0, AJ_NO_FLAGS, CALL_TIMEOUT);
/*
* Marshal local peer GUID, remote peer GUID, and local peer's GUID
*/
{
char guidStr[33];
AJ_GUID localGuid;
AJ_GetLocalGUID(&localGuid);
AJ_GUID_ToString(&localGuid, guidStr, sizeof(guidStr));
AJ_MarshalArgs(&call, "s", guidStr);
AJ_GUID_ToString(authContext.peerGuid, guidStr, sizeof(guidStr));
AJ_RandHex(authContext.nonce, sizeof(authContext.nonce), NONCE_LEN);
AJ_MarshalArgs(&call, "ss", guidStr, authContext.nonce);
}
return AJ_DeliverMsg(&call);
}
AJ_Status AJ_PeerHandleExchangeGUIDs(AJ_Message* msg, AJ_Message* reply)
{
char guidStr[33];
uint32_t version;
char* str;
AJ_GUID remoteGuid;
AJ_GUID localGuid;
AJ_UnmarshalArgs(msg, "su", &str, &version);
AJ_GUID_FromString(&remoteGuid, str);
AJ_GUID_AddNameMapping(&remoteGuid, msg->sender, NULL);
/*
* We are not currently negotiating versions so we tell the peer what version we require.
*/
version = REQUIRED_AUTH_VERSION;
AJ_MarshalReplyMsg(msg, reply);
AJ_GetLocalGUID(&localGuid);
AJ_GUID_ToString(&localGuid, guidStr, sizeof(guidStr));
return AJ_MarshalArgs(reply, "su", guidStr, version);
}
/*
* Responder side of the SASL conversation
*/
static AJ_Status Response(AJ_SASL_Context* context, char* inStr, char* outStr, uint32_t outLen)
{
AJ_Status status = AJ_OK;
AJ_AuthResult result;
const char* cmd;
const char* rsp = outStr;
if (context->state == AJ_SASL_SEND_AUTH_REQ) {
cmd = CMD_REJECTED;
} else {
cmd = ParseCmd(&inStr);
}
/*
* The REJECTED command is handled the same in all states
*/
if (cmd == CMD_REJECTED) {
context->nextMech++;
context->mechanism = SelectAuth(context, "");
if (!context->mechanism) {
/*
* No mechanism in common so authentication fails.
*/
return AJ_ERR_SECURITY;
}
status = context->mechanism->Init(AJ_AUTH_RESPONDER, context->pwdFunc);
/*
* Initialization must succeed
*/
if (status != AJ_OK) {
return status;
}
result = context->mechanism->Response(NULL, outStr, outLen);
if ((result == AJ_AUTH_STATUS_SUCCESS) || (result == AJ_AUTH_STATUS_CONTINUE)) {
status = PrependStr(context->mechanism->name, outStr, outLen, TRUE);
if (status == AJ_OK) {
status = PrependStr(CMD_AUTH, outStr, outLen, FALSE);
}
if (status == AJ_OK) {
status = AppendCRLF(outStr, outLen);
}
context->state = (result == AJ_AUTH_STATUS_SUCCESS) ? AJ_SASL_WAIT_FOR_OK : AJ_SASL_WAIT_FOR_DATA;
} else {
status = AJ_ERR_SECURITY;
}
return status;
}
switch (context->state) {
case AJ_SASL_WAIT_FOR_DATA:
if (cmd == CMD_DATA) {
status = HexDecode(inStr);
if (status == AJ_OK) {
result = context->mechanism->Response(inStr, outStr, outLen);
if (result == AJ_AUTH_STATUS_SUCCESS) {
status = PrependStr(CMD_DATA, outStr, outLen, TRUE);
context->state = AJ_SASL_WAIT_FOR_OK;
} else if (result == AJ_AUTH_STATUS_ERROR) {
status = context->mechanism->Init(AJ_AUTH_RESPONDER, context->pwdFunc);
/*
* Initialization must succeed
*/
if (status != AJ_OK) {
return status;
}
context->state = AJ_SASL_WAIT_FOR_REJECT;
rsp = CMD_CANCEL;
} else if (result != AJ_AUTH_STATUS_CONTINUE) {
if (result == AJ_AUTH_STATUS_RETRY &&
context->mechList[context->nextMech + 1] != NULL) {
// Notify the challenger to give up on the current authentication mechanism and to be in WAIT_FOR_AUTH state
rsp = CMD_ERROR;
} else {
status = AJ_ERR_SECURITY;
}
}
}
break;
}
/* Fallthrough */
case AJ_SASL_WAIT_FOR_OK:
if (cmd == CMD_OK) {
AJ_GUID localGuid;
AJ_GetLocalGUID(&localGuid);
status = AJ_GUID_ToString(&localGuid, outStr, outLen);
if (status == AJ_OK) {
status = PrependStr(CMD_BEGIN, outStr, outLen, FALSE);
}
context->state = AJ_SASL_AUTHENTICATED;
} else if (cmd == CMD_DATA) {
rsp = CMD_CANCEL;
context->state = AJ_SASL_WAIT_FOR_REJECT;
} else if (cmd == CMD_ERROR) {
rsp = CMD_CANCEL;
context->state = AJ_SASL_WAIT_FOR_REJECT;
} else {
rsp = CMD_ERROR;
}
break;
case AJ_SASL_WAIT_FOR_REJECT:
status = AJ_ERR_SECURITY;
break;
default:
status = AJ_ERR_UNEXPECTED;
}
if (status == AJ_OK) {
if (rsp != outStr) {
status = SetStr(rsp, outStr, outLen);
}
}
if (status == AJ_OK) {
status = AppendCRLF(outStr, outLen);
}
return status;
}
/*
* Challenger side of the SASL conversation
*/
static AJ_Status Challenge(AJ_SASL_Context* context, char* inStr, char* outStr, uint32_t outLen)
{
AJ_Status status = AJ_OK;
AJ_AuthResult result;
const char* rsp = outStr;
const char* cmd = ParseCmd(&inStr);
/*
* The ERROR command is handled the same in all states.
*/
if (cmd == CMD_ERROR || ((cmd == CMD_CANCEL) && (context->state != AJ_SASL_WAIT_FOR_AUTH))) {
status = Rejected(context, outStr, outLen);
if (status == AJ_OK) {
status = AppendCRLF(outStr, outLen);
}
context->state = AJ_SASL_WAIT_FOR_AUTH;
return status;
}
switch (context->state) {
case AJ_SASL_WAIT_FOR_AUTH:
if (cmd == CMD_AUTH) {
context->mechanism = MatchMechanism(context, &inStr);
if (!context->mechanism) {
result = AJ_AUTH_STATUS_RETRY;
status = Rejected(context, outStr, outLen);
break;
} else {
status = context->mechanism->Init(AJ_AUTH_CHALLENGER, context->pwdFunc);
/*
* Initialization must succeed
*/
if (status != AJ_OK) {
break;
}
}
/*
* Data following an AUTH command is handled sames as DATA command
*/
if ((*inStr) || (strcmp(context->mechanism->name, "ANONYMOUS") == 0)) {
cmd = CMD_DATA;
} else {
break;
}
}
/* Falling through */
case AJ_SASL_WAIT_FOR_DATA:
if (cmd == CMD_DATA) {
if (strcmp(context->mechanism->name, "ANONYMOUS") != 0) {
status = HexDecode(inStr);
}
if (status == AJ_OK) {
result = context->mechanism->Challenge(inStr, outStr, outLen);
if (result == AJ_AUTH_STATUS_SUCCESS) {
AJ_GUID localGuid;
AJ_GetLocalGUID(&localGuid);
status = AJ_GUID_ToString(&localGuid, outStr, outLen);
if (status == AJ_OK) {
status = PrependStr(CMD_OK, outStr, outLen, FALSE);
}
context->state = AJ_SASL_WAIT_FOR_BEGIN;
} else if (result == AJ_AUTH_STATUS_CONTINUE) {
status = PrependStr(CMD_DATA, outStr, outLen, TRUE);
context->state = AJ_SASL_WAIT_FOR_DATA;
} else if (result == AJ_AUTH_STATUS_RETRY) {
status = Rejected(context, outStr, outLen);
} else if (result == AJ_AUTH_STATUS_FAILURE) {
status = AJ_ERR_SECURITY;
} else {
rsp = CMD_ERROR;
}
}
} else if (cmd == CMD_BEGIN) {
status = AJ_ERR_SECURITY;
} else {
rsp = CMD_ERROR;
}
break;
case AJ_SASL_WAIT_FOR_BEGIN:
if (cmd == CMD_BEGIN) {
context->state = AJ_SASL_AUTHENTICATED;
} else {
rsp = CMD_ERROR;
}
break;
default:
status = AJ_ERR_UNEXPECTED;
}
if (status == AJ_OK) {
if (rsp != outStr) {
status = SetStr(rsp, outStr, outLen);
}
}
/* The Challenger does not send out any SASL message once the state is AJ_SASL_AUTHENTICATED
i.e after the BEGIN command is received. So we should not append the CRLF. This results
in unwanted bytes being put in the tx buffer which gets sent out to the Responder. */
if ((status == AJ_OK) && (context->state != AJ_SASL_AUTHENTICATED)) {
status = AppendCRLF(outStr, outLen);
}
return status;
}
AJ_Status AJ_ARDP_UDP_Connect(AJ_BusAttachment* bus, void* context, const AJ_Service* service, AJ_NetSocket* netSock)
{
AJ_Message hello;
AJ_GUID localGuid;
char guid_buf[33];
AJ_Status status;
AJ_Message helloResponse;
AJ_GetLocalGUID(&localGuid);
AJ_GUID_ToString(&localGuid, guid_buf, sizeof(guid_buf));
AJ_MarshalMethodCall(bus, &hello, AJ_METHOD_BUS_SIMPLE_HELLO, AJ_BusDestination, 0, AJ_FLAG_ALLOW_REMOTE_MSG, AJ_UDP_CONNECT_TIMEOUT);
AJ_MarshalArgs(&hello, "su", guid_buf, 10);
hello.hdr->bodyLen = hello.bodyBytes;
status = AJ_ARDP_Connect(bus->sock.tx.readPtr, AJ_IO_BUF_AVAIL(&bus->sock.tx), context, netSock);
if (status != AJ_OK)
{
return status;
}
status = AJ_UnmarshalMsg(bus, &helloResponse, AJ_UDP_CONNECT_TIMEOUT);
if (status == AJ_OK && helloResponse.msgId == AJ_REPLY_ID(AJ_METHOD_BUS_SIMPLE_HELLO))
{
if (helloResponse.hdr->msgType == AJ_MSG_ERROR)
{
status = AJ_ERR_CONNECT;
}
else
{
AJ_Arg uniqueName, protoVersion;
AJ_UnmarshalArg(&helloResponse, &uniqueName);
AJ_SkipArg(&helloResponse);
AJ_UnmarshalArg(&helloResponse, &protoVersion);
/**
* The two most-significant bits are reserved for the nameType,
* which we don't currently care about in the thin client
*/
routingProtoVersion = (uint8_t) ((*protoVersion.val.v_uint32) & 0x3FFFFFFF);
if (uniqueName.len >= (sizeof(bus->uniqueName) - 1))
{
AJ_ErrPrintf(("AJ_ARDP_Connect(): AJ_ERR_RESOURCES\n"));
status = AJ_ERR_RESOURCES;
}
else
{
memcpy(bus->uniqueName, uniqueName.val.v_string, uniqueName.len);
bus->uniqueName[uniqueName.len] = '\0';
}
/AJ_InfoPrintf(("Received name: %s and version %u\n", bus->uniqueName, routingProtoVersion));
if (routingProtoVersion < AJ_GetMinProtoVersion())
{
AJ_InfoPrintf(("AJ_ARDP_Connect(): Blacklisting routing node, found %u but require >= %u\n",
routingProtoVersion, AJ_GetMinProtoVersion()));
AddRoutingNodeToBlacklist(service);
status = AJ_ERR_CONNECT;
}
}
}
AJ_Status TestCreds()
{
AJ_Status status = AJ_OK;
AJ_GUID localGuid;
AJ_GUID remoteGuid;
char str[33];
AJ_PeerCred*peerCredRead;
int i = 0;
AJ_GUID peerGuid;
uint8_t secretLen = 24;
uint8_t secret[24];
uint32_t expiration = 50898;
char hex[100];
AJ_AlwaysPrintf(("Start TestCreds\n"));
status = AJ_GetLocalGUID(&localGuid);
if (AJ_OK != status) {
return status;
}
AJ_GUID_FromString(&localGuid, str);
AJ_InfoPrintf(("TestCreds() Layout Print\n"));
AJ_NVRAM_Layout_Print();
memset(&peerGuid, 1, sizeof(AJ_GUID));
for (i = 0; i < secretLen; i++) {
secret[i] = i;
}
AJ_GUID_ToString(&peerGuid, hex, 100);
AJ_AlwaysPrintf(("AJ_StorePeerSecret guid %s\n", hex));
status = AJ_StorePeerSecret(&peerGuid, secret, secretLen, expiration);
memcpy(&remoteGuid, &peerGuid, sizeof(AJ_GUID)); // backup the GUID
if (AJ_OK != status) {
AJ_AlwaysPrintf(("AJ_StorePeerSecret failed = %d\n", status));
return status;
}
AJ_NVRAM_Layout_Print();
AJ_InfoPrintf(("TestCreds() StoreCred() Layout Print\n"));
AJ_NVRAM_Layout_Print();
AJ_GUID_ToString(&remoteGuid, hex, 100);
AJ_AlwaysPrintf(("AJ_GetPeerCredential guid %s\n", hex));
status = AJ_GetPeerCredential(&remoteGuid, &peerCredRead);
if (AJ_OK != status) {
AJ_AlwaysPrintf(("AJ_GetPeerCredential failed = %d\n", status));
return status;
}
if (0 != memcmp(peerCredRead->id, &peerGuid, peerCredRead->idLen)) {
AJ_AlwaysPrintf(("The retrieved credential does not match\n"));
AJ_FreeCredential(peerCredRead);
return AJ_ERR_FAILURE;
}
if (peerCredRead->dataLen != secretLen) {
AJ_AlwaysPrintf(("no match for secretLen got %d expected %d\n",
peerCredRead->dataLen, secretLen));
AJ_FreeCredential(peerCredRead);
return AJ_ERR_FAILURE;
}
if (secretLen > 0) {
if (0 != memcmp(peerCredRead->data, secret, secretLen)) {
AJ_AlwaysPrintf(("no match for secret\n"));
AJ_FreeCredential(peerCredRead);
return AJ_ERR_FAILURE;
}
}
if (peerCredRead->expiration != expiration) {
AJ_AlwaysPrintf(("no match for expiration got %d expected %d\n",
peerCredRead->expiration, expiration));
AJ_FreeCredential(peerCredRead);
return AJ_ERR_FAILURE;
}
status = AJ_DeletePeerCredential(&remoteGuid);
if (AJ_OK != status) {
AJ_AlwaysPrintf(("AJ_DeleteCredential failed = %d\n", status));
AJ_FreeCredential(peerCredRead);
return status;
}
AJ_FreeCredential(peerCredRead);
if (AJ_ERR_FAILURE == AJ_GetPeerCredential(&remoteGuid, NULL)) {
status = AJ_OK;
} else {
return AJ_ERR_FAILURE;
}
AJ_InfoPrintf(("TestCreds() Layout Print\n"));
AJ_NVRAM_Layout_Print();
AJ_ClearCredentials();
if (AJ_ERR_FAILURE == AJ_GetPeerCredential(&remoteGuid, NULL)) {
status = AJ_OK;
} else {
return AJ_ERR_FAILURE;
}
AJ_InfoPrintf(("TestCreds() Layout Print\n"));
AJ_NVRAM_Layout_Print();
AJ_AlwaysPrintf(("TestCreds done.\n"));
return status;
}
static AJ_Status AboutPropGetter(AJ_Message* reply, const char* language)
{
AJ_Status status = AJ_OK;
AJ_Arg array;
AJ_GUID theAJ_GUID;
char machineIdValue[UUID_LENGTH * 2 + 1];
machineIdValue[UUID_LENGTH * 2] = '\0';
if ((language != NULL) && (0 != strcmp(language, "en")) && (0 != strcmp(language, ""))) {
/* the language supplied was not supported */
status = AJ_ERR_NO_MATCH;
}
if (status == AJ_OK) {
status = AJ_MarshalContainer(reply, &array, AJ_ARG_ARRAY);
if (status == AJ_OK) {
status = AJ_GetLocalGUID(&theAJ_GUID);
if (status == AJ_OK) {
AJ_GUID_ToString(&theAJ_GUID, machineIdValue, UUID_LENGTH * 2 + 1);
}
if (status == AJ_OK) {
status = MarshalAppId(reply, &machineIdValue[0]);
}
if (status == AJ_OK) {
status = AJ_MarshalArgs(reply, "{sv}", "AppName", "s", "svclite");
}
if (status == AJ_OK) {
status = AJ_MarshalArgs(reply, "{sv}", "DeviceId", "s", machineIdValue);
}
if (status == AJ_OK) {
status = AJ_MarshalArgs(reply, "{sv}", "DeviceName", "s", "Tester");
}
if (status == AJ_OK) {
status = AJ_MarshalArgs(reply, "{sv}", "Manufacturer", "s", "QCE");
}
if (status == AJ_OK) {
status = AJ_MarshalArgs(reply, "{sv}", "ModelNumber", "s", "1.0");
}
//SupportedLanguages
if (status == AJ_OK) {
AJ_Arg dict;
AJ_Arg languageListArray;
status = AJ_MarshalContainer(reply, &dict, AJ_ARG_DICT_ENTRY);
if (status == AJ_OK) {
status = AJ_MarshalArgs(reply, "s", "SupportedLanguages");
}
if (status == AJ_OK) {
status = AJ_MarshalVariant(reply, "as");
}
if (status == AJ_OK) {
status = AJ_MarshalContainer(reply, &languageListArray, AJ_ARG_ARRAY);
}
if (status == AJ_OK) {
status = AJ_MarshalArgs(reply, "s", "en");
}
if (status == AJ_OK) {
status = AJ_MarshalCloseContainer(reply, &languageListArray);
}
if (status == AJ_OK) {
status = AJ_MarshalCloseContainer(reply, &dict);
}
}
if (status == AJ_OK) {
status = AJ_MarshalArgs(reply, "{sv}", "Description", "s", "svclite test app");
}
if (status == AJ_OK) {
status = AJ_MarshalArgs(reply, "{sv}", "DefaultLanguage", "s", "en");
}
if (status == AJ_OK) {
status = AJ_MarshalArgs(reply, "{sv}", "SoftwareVersion", "s", AJ_GetVersion());
}
if (status == AJ_OK) {
status = AJ_MarshalArgs(reply, "{sv}", "AJSoftwareVersion", "s", AJ_GetVersion());
}
}
if (status == AJ_OK) {
status = AJ_MarshalCloseContainer(reply, &array);
}
}
return status;
}
