AJ_Status unmarshalTimePropertyValue(TimePropertyValue* timePropertyValue, AJ_Message* message)
{
AJ_Status status;
AJ_Arg outerStructArg, innerStructArg;
uint16_t widgetType;
status = AJ_UnmarshalContainer(message, &outerStructArg, AJ_ARG_STRUCT);
if (status != AJ_OK) {
return status;
}
status = AJ_UnmarshalArgs(message, "q", &widgetType);
if (status != AJ_OK) {
return status;
}
if (widgetType != TIME_PROPERTY) {
return AJ_ERR_UNEXPECTED;
}
status = AJ_UnmarshalContainer(message, &innerStructArg, AJ_ARG_STRUCT);
if (status != AJ_OK) {
return status;
}
status = AJ_UnmarshalArgs(message, "qqq", &timePropertyValue->hour, &timePropertyValue->minute, &timePropertyValue->second);
if (status != AJ_OK) {
return status;
}
status = AJ_UnmarshalCloseContainer(message, &innerStructArg);
if (status != AJ_OK) {
return status;
}
return AJ_UnmarshalCloseContainer(message, &outerStructArg);
}
AJ_Status unmarshalDatePropertyValue(DatePropertyValue* datePropertyValue, AJ_Message* message)
{
AJ_Status status;
AJ_Arg outerStructArg, innerStructArg;
uint16_t widgetType;
status = AJ_UnmarshalContainer(message, &outerStructArg, AJ_ARG_STRUCT);
if (status != AJ_OK) {
return status;
}
status = AJ_UnmarshalArgs(message, "q", &widgetType);
if (status != AJ_OK) {
return status;
}
if (widgetType != DATE_PROPERTY) {
return AJ_ERR_UNEXPECTED;
}
status = AJ_UnmarshalContainer(message, &innerStructArg, AJ_ARG_STRUCT);
if (status != AJ_OK) {
return status;
}
status = AJ_UnmarshalArgs(message, "qqq", &datePropertyValue->mDay, &datePropertyValue->month, &datePropertyValue->fullYear);
if (status != AJ_OK) {
return status;
}
status = AJ_UnmarshalCloseContainer(message, &innerStructArg);
if (status != AJ_OK) {
return status;
}
return AJ_UnmarshalCloseContainer(message, &outerStructArg);
}
AJ_Status AJS_UnmarshalPropArgs(duk_context* ctx, AJ_Message* msg, uint8_t accessor, duk_idx_t msgIdx)
{
AJ_Status status;
const char* iface;
const char* prop;
const char* signature;
uint32_t propId;
uint8_t secure = FALSE;
AJ_InfoPrintf(("PushPropArgs\n"));
if (accessor == AJ_PROP_GET_ALL) {
status = AJ_UnmarshalArgs(msg, "s", &iface);
if (status == AJ_OK) {
duk_push_string(ctx, iface);
/*
* Save interface (read-only) so we know how to marshal the reply values
*/
duk_push_string(ctx, AJS_HIDDEN_PROP("propIface"));
duk_dup(ctx, -2);
duk_def_prop(ctx, msgIdx, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_HAVE_WRITABLE);
}
/*
* This call always returns an error status because the interface name we are passing in is
* invalid but it will indicate if security is required so we can perform the check below
*/
AJ_IdentifyProperty(msg, iface, "", &propId, &signature, &secure);
} else {
status = AJ_UnmarshalArgs(msg, "ss", &iface, &prop);
if (status == AJ_OK) {
status = AJ_IdentifyProperty(msg, iface, prop, &propId, &signature, &secure);
if (status == AJ_OK) {
duk_push_string(ctx, iface);
duk_push_string(ctx, prop);
if (accessor == AJ_PROP_GET) {
/*
* If we are getting a property save the signature so we know how to marshal the
* value in the reply.
*/
duk_push_string(ctx, AJS_HIDDEN_PROP("propSig"));
duk_push_string(ctx, signature);
duk_def_prop(ctx, msgIdx, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_HAVE_WRITABLE);
} else {
/*
* Push the value to set
*/
status = PushArg(ctx, msg);
}
}
}
}
/*
* If the interface is secure check the message is encrypted
*/
if ((status == AJ_OK) && secure && !(msg->hdr->flags & AJ_FLAG_ENCRYPTED)) {
status = AJ_ERR_SECURITY;
AJ_WarnPrintf(("Security violation accessing property\n"));
}
return status;
}
uint8_t isControlPanelAnnounce(AJ_Message* msg)
{
AJ_Status status = AJ_OK;
AJ_Arg array1, array2, struct1;
uint16_t uint1, uint2;
char* buffer;
status = AJ_UnmarshalArgs(msg, "q", &uint1);
if (status != AJ_OK) {
return FALSE;
}
status = AJ_UnmarshalArgs(msg, "q", &uint2);
if (status != AJ_OK) {
return FALSE;
}
status = AJ_UnmarshalContainer(msg, &array1, AJ_ARG_ARRAY);
if (status != AJ_OK) {
return FALSE;
}
do {
status = AJ_UnmarshalContainer(msg, &struct1, AJ_ARG_STRUCT);
if (status != AJ_OK) {
return FALSE;
}
status = AJ_UnmarshalArgs(msg, "o", &buffer);
if (status != AJ_OK) {
return FALSE;
}
status = AJ_UnmarshalContainer(msg, &array2, AJ_ARG_ARRAY);
if (status != AJ_OK) {
return FALSE;
}
do {
if ((status = AJ_UnmarshalArgs(msg, "s", &buffer)) != AJ_OK) {
if (status == AJ_ERR_NO_MORE) {
break;
} else {
return FALSE;
}
}
if (strcmp(buffer, "org.alljoyn.ControlPanel.ControlPanel") == 0) {
return TRUE;
}
} while (1);
status = AJ_UnmarshalCloseContainer(msg, &array2);
if (status != AJ_OK) {
break;
}
status = AJ_UnmarshalCloseContainer(msg, &struct1);
if (status != AJ_OK) {
break;
}
} while (1);
return FALSE;
}
static AJ_Status SessionBindReply(duk_context* ctx, AJ_Message* msg)
{
AJ_Status status;
uint32_t result;
uint16_t port;
uint8_t ldstate;
status = AJ_UnmarshalArgs(msg, "uq", &result, &port);
if (status != AJ_OK) {
return status;
}
if (port != AJS_APP_PORT) {
AJ_ResetArgs(msg);
#if !defined(AJS_CONSOLE_LOCKDOWN)
status = AJS_GetLockdownState(&ldstate);
if (status == AJ_OK && ldstate == AJS_CONSOLE_UNLOCKED) {
status = AJS_ConsoleMsgHandler(ctx, msg);
}
#endif
if (status == AJ_ERR_NO_MATCH) {
status = AJS_ServicesMsgHandler(msg);
if (status == AJ_ERR_NO_MATCH) {
status = AJ_OK;
}
}
}
return status;
}
static AJ_Status AppHandleCat(AJ_Message* msg)
{
#define BUFFER_SIZE 256
const char* string0;
const char* string1;
char buffer[BUFFER_SIZE];
AJ_Message reply;
AJ_Arg replyArg;
AJ_UnmarshalArgs(msg, "ss", &string0, &string1);
AJ_MarshalReplyMsg(msg, &reply);
/* We have the arguments. Now do the concatenation. */
strncpy(buffer, string0, BUFFER_SIZE);
buffer[BUFFER_SIZE - 1] = '\0';
strncat(buffer, string1, BUFFER_SIZE - strlen(buffer));
buffer[BUFFER_SIZE - 1] = '\0';
AJ_InitArg(&replyArg, AJ_ARG_STRING, 0, buffer, 0);
AJ_MarshalArg(&reply, &replyArg);
return AJ_DeliverMsg(&reply);
#undef BUFFER_SIZE
}
AJ_Status AppHandleCat(AJ_Message* msg)
{
AJ_Status status = AJ_OK;
AJ_Message reply;
char* partA;
char* partB;
char* totalString;
AJ_AlwaysPrintf(("%s:%d:%s %d\n", __FILE__, __LINE__, __FUNCTION__, 0));
AJ_UnmarshalArgs(msg, "ss", &partA, &partB);
totalString = (char*) AJ_Malloc(strlen(partA) + strlen(partB) + 1);
if (!totalString) {
return AJ_ERR_RESOURCES;
}
strcpy(totalString, partA);
strcpy(totalString + strlen(partA), partB);
AJ_MarshalReplyMsg(msg, &reply);
AJ_MarshalArgs(&reply, "s", totalString);
status = AJ_DeliverMsg(&reply);
AJ_Free(totalString);
return status;
}
AJ_Status AJCFG_GetConfigurationsHandler(AJ_Message* msg)
{
AJ_Status status = AJ_OK;
AJ_Message reply;
char* language;
int8_t langIndex = AJSVC_PROPERTY_STORE_ERROR_LANGUAGE_INDEX;
AJSVC_PropertyStoreCategoryFilter filter;
AJ_InfoPrintf(("Handling GetConfigurations request\n"));
memset(&filter, 0, sizeof(AJSVC_PropertyStoreCategoryFilter));
filter.bit1Config = TRUE;
status = AJ_UnmarshalArgs(msg, "s", &language);
if (status != AJ_OK) {
return status;
}
if (AJSVC_IsLanguageSupported(msg, &reply, language, &langIndex)) {
status = AJ_MarshalReplyMsg(msg, &reply);
if (status != AJ_OK) {
return status;
}
status = AJSVC_PropertyStore_ReadAll(&reply, filter, langIndex);
if (status != AJ_OK) {
return status;
}
}
status = AJ_DeliverMsg(&reply);
if (status != AJ_OK) {
return status;
}
return status;
}
AJ_Status AJSUSI_VgaGetBacklightBrightness_Handler(AJ_Message* msg)
{
AJ_Status status = AJ_OK;
AJ_Message reply;
AJ_Arg replyArg;
uint32_t id, bright;
//Get Args
status = AJ_UnmarshalArgs(msg, "u", &id);
if (status != AJ_OK) {
return status;
}
AJ_InfoPrintf(("%s : id=%d\n", __func__, id));
//SUSI API
if (AJ_SusiVgaGetBacklightBrightness(id, &bright)) {
AJ_MarshalErrorMsg(msg, &reply, AJ_ErrFeatureNotAvailable);
return AJ_DeliverMsg(&reply);
}
//Status Reply
AJ_InfoPrintf(("%s : ret=0x%x\n", __func__, bright));
AJ_InitArg(&replyArg, AJ_ARG_UINT32, 0, &bright, 0);
return SendReplyMsg(msg, &replyArg);
}
static AJSVC_ServiceStatus AJApp_MessageProcessor(AJ_BusAttachment* busAttachment, AJ_Message* msg, AJ_Status* status)
{
AJSVC_ServiceStatus serviceStatus = AJSVC_SERVICE_STATUS_HANDLED;
uint16_t port;
char* joiner;
uint32_t sessionId = 0;
uint8_t session_accepted = FALSE;
if (msg->msgId == AJ_METHOD_ACCEPT_SESSION) { // Process all incoming request to join a session and pass request for acceptance by all services
*status = AJ_UnmarshalArgs(msg, "qus", &port, &sessionId, &joiner);
if (*status != AJ_OK) {
return serviceStatus;
}
session_accepted |= (port == AJ_ABOUT_SERVICE_PORT);
session_accepted |= AJSVC_CheckSessionAccepted(port, sessionId, joiner);
*status = AJ_BusReplyAcceptSession(msg, session_accepted);
AJ_AlwaysPrintf(("%s session session_id=%u joiner=%s for port %u\n", (session_accepted ? "Accepted" : "Rejected"), sessionId, joiner, port));
} else {
switch (currentServicesInitializationState) {
case INIT_SERVICES_PORT:
if (msg->msgId == AJ_REPLY_ID(AJ_METHOD_BIND_SESSION_PORT)) {
currentServicesInitializationState = nextServicesInitializationState;
}
break;
default:
serviceStatus = AJSVC_MessageProcessorAndDispatcher(busAttachment, msg, status);
break;
}
}
return serviceStatus;
}
AJ_Status AJNS_Consumer_DismissSignalHandler(AJ_Message* msg)
{
AJ_Status status;
uint32_t notificationId = 0;
char appId[UUID_LENGTH * 2 + 1];
status = AJ_UnmarshalArgs(msg, "i", ¬ificationId);
if (status != AJ_OK) {
goto Exit;
}
status = AJSVC_UnmarshalAppId(msg, appId, sizeof(appId));
if (status != AJ_OK) {
goto Exit;
}
if (appOnDismiss) {
(*appOnDismiss)(notificationId, appId);
}
Exit:
AJ_CloseMsg(msg);
return status;
}
int UnmarshalPort() {
uint16_t port;
char* joiner;
uint32_t sessionId;
AJ_UnmarshalArgs(&c_message, "qus", &port, &sessionId, &joiner);
return port;
}
/*
* Handles a property SET request so unmarshals the property value to apply.
*/
static AJ_Status PropSetHandler(AJ_Message* replyMsg, uint32_t propId, void* context)
{
if (propId == APP_INT_VAL_PROP) {
return AJ_UnmarshalArgs(replyMsg, "i", &propVal);
} else {
return AJ_ERR_UNEXPECTED;
}
}
AJ_Status AJS_SessionLost(duk_context* ctx, AJ_Message* msg)
{
uint32_t sessionId;
AJ_UnmarshalArgs(msg, "u", &sessionId);
AJ_InfoPrintf(("AJS_SessionLost(): Removing session: %u\n", sessionId));
return RemoveSessions(ctx, sessionId);
}
AJ_Status AppHandleChatSignal(AJ_Message* msg)
{
AJ_Status status = AJ_OK;
char* chatString;
AJ_UnmarshalArgs(msg, "s", &chatString);
AJ_AlwaysPrintf(("RX chat from %s[%u]: %s\n", msg->sender, msg->sessionId, chatString));
return status;
}
AJ_Status AJCFG_SetPasscodeHandler(AJ_Message* msg)
{
AJ_Status status = AJ_OK;
char* daemonRealm;
AJ_Arg newPasscode;
AJ_Message reply;
uint8_t forceRoutingNodeDisconnect = FALSE;
uint8_t errorReply = FALSE;
AJ_InfoPrintf(("Handling SetPasscode request\n"));
status = AJ_UnmarshalArgs(msg, "s", &daemonRealm);
if (status != AJ_OK) {
return status;
}
AJ_InfoPrintf(("Realm=%s\n", daemonRealm));
status = AJ_UnmarshalArg(msg, &newPasscode);
if (status != AJ_OK) {
return status;
}
AJ_InfoPrintf(("Passcode=%d bytes long\n", newPasscode.len));
if (newPasscode.len > 0) { // Check passcode is not empty
if (AppSetPasscode) {
status = (AppSetPasscode)(daemonRealm, (const uint8_t*)newPasscode.val.v_string, (uint8_t)newPasscode.len);
if (status == AJ_ERR_RESOURCES) { // Check passcode is too long to persist
status = AJ_MarshalErrorMsg(msg, &reply, AJSVC_ERROR_MAX_SIZE_EXCEEDED);
if (status != AJ_OK) {
return status;
}
errorReply = TRUE;
}
forceRoutingNodeDisconnect = (status == AJ_ERR_READ);
}
} else {
AJ_ErrPrintf(("Error - newPasscode cannot be empty!\n"));
status = AJ_MarshalErrorMsg(msg, &reply, AJSVC_ERROR_INVALID_VALUE);
if (status != AJ_OK) {
return status;
}
errorReply = TRUE;
}
if (!errorReply) {
status = AJ_MarshalReplyMsg(msg, &reply);
if (status != AJ_OK) {
return status;
}
}
status = AJ_DeliverMsg(&reply);
if (forceRoutingNodeDisconnect) {
return AJ_ERR_READ;
}
return status;
}
AJ_Status AJ_PeerHandleGenSessionKeyReply(AJ_Message* msg)
{
AJ_Status status;
/*
* For 12 bytes of verifier, we need at least 12 * 2 characters
* to store its representation in hex (24 octets + 1 octet for \0).
* However, the KeyGen function demands a bigger buffer
* (to store 16 bytes key in addition to the 12 bytes verifier).
* Hence we allocate, the maximum of (12 * 2 + 1) and (16 + 12).
*/
char verifier[VERIFIER_LEN + AES_KEY_LEN];
char* nonce;
char* remVerifier;
/*
* Check we are in an auth conversation with the sender
*/
status = CheckAuthPeer(msg);
if (status != AJ_OK) {
return status;
}
if (msg->hdr->msgType == AJ_MSG_ERROR) {
status = AJ_ERR_SECURITY;
} else {
AJ_UnmarshalArgs(msg, "ss", &nonce, &remVerifier);
status = KeyGen(msg->sender, AJ_ROLE_KEY_INITIATOR, authContext.nonce, nonce, (uint8_t*)verifier, sizeof(verifier));
if (status == AJ_OK) {
/*
* Check verifier strings match as expected
*/
if (strcmp(remVerifier, verifier) != 0) {
status = AJ_ERR_SECURITY;
}
}
if (status == AJ_OK) {
AJ_Arg key;
AJ_Message call;
uint8_t groupKey[AES_KEY_LEN];
/*
* Group keys are exchanged via an encrypted message
*/
AJ_MarshalMethodCall(msg->bus, &call, AJ_METHOD_EXCHANGE_GROUP_KEYS, msg->sender, 0, AJ_FLAG_ENCRYPTED, CALL_TIMEOUT);
AJ_GetGroupKey(NULL, groupKey);
AJ_MarshalArg(&call, AJ_InitArg(&key, AJ_ARG_BYTE, AJ_ARRAY_FLAG, groupKey, sizeof(groupKey)));
status = AJ_DeliverMsg(&call);
}
}
if (status != AJ_OK) {
PeerAuthComplete(status);
}
return AJ_OK;
}
static AJ_Status AppHandleFlash(AJ_Message* msg)
{
AJ_Message reply;
uint32_t timeout;
AJ_UnmarshalArgs(msg, "u", &timeout);
AJ_AlwaysPrintf(("AppHandleFlash(%u)\n", timeout));
DUE_led_timed(timeout);
AJ_MarshalReplyMsg(msg, &reply);
return AJ_DeliverMsg(&reply);
}
AJ_Status AJ_GUID_HandleNameOwnerChanged(AJ_Message* msg)
{
AJ_Status status;
char* name;
char* oldOwner;
char* newOwner;
status = AJ_UnmarshalArgs(msg, "sss", &name, &oldOwner, &newOwner);
// AJ_InfoPrintf(("AJ_GUID_HandleNameOwnerChanged(name=%s,oldOwner=%s,newOwner=%s)\n", name, oldOwner, newOwner));
if ((status == AJ_OK) && newOwner && oldOwner && newOwner[0] == '\0')
{
AJ_GUID_DeleteNameMapping(msg->bus, oldOwner);
}
return status;
}
static AJ_Status SetName(AJ_Message* replyMsg, uint32_t propId, void* context)
{
AJ_Status status = AJ_ERR_UNEXPECTED;
if (propId == BASIC_SIGNAL_SERVICE_NAME_ID) {
char*string;
AJ_UnmarshalArgs(replyMsg, "s", &string);
strncpy(propertyName, string, propertyNameSize);
propertyName[propertyNameSize - 1] = '\0';
AJ_AlwaysPrintf(("Set 'name' property was called changing name to '%s'.\n", propertyName));
status = AJ_OK;
}
return status;
}
AJ_Status unmarshalPropertyValue(PropertyWidget* widget, AJ_Message* message, void* newValue, const char* lockerId)
{
AJ_Status status = AJ_ERR_UNEXPECTED;
switch (widget->propertyType) {
case SINGLE_VALUE_PROPERTY:
return AJ_UnmarshalArgs(message, widget->signature, newValue);
case DATE_VALUE_PROPERTY:
return unmarshalDatePropertyValue(newValue, message);
case TIME_VALUE_PROPERTY:
return unmarshalTimePropertyValue(newValue, message);
}
return status;
}
static AJ_Status SessionDispatcher(duk_context* ctx, AJ_Message* msg)
{
AJ_Status status;
uint32_t sessionId;
uint16_t port;
char* joiner;
uint8_t ldstate;
status = AJ_UnmarshalArgs(msg, "qus", &port, &sessionId, &joiner);
if (status != AJ_OK) {
return status;
}
/*
* Automatically accept sessions requests to the application port
*/
if (port == AJS_APP_PORT) {
return AJS_HandleAcceptSession(ctx, msg, port, sessionId, joiner);
}
/*
* See if this is the control panel port
*/
if (AJCPS_CheckSessionAccepted(port, sessionId, joiner)) {
return AJ_BusReplyAcceptSession(msg, TRUE);
}
status = AJ_ResetArgs(msg);
if (status != AJ_OK) {
return status;
}
/*
* JavaScript doesn't accept/reject session so the session is either for the console or perhaps
* a service if the services bind their own ports.
*/
#if !defined(AJS_CONSOLE_LOCKDOWN)
status = AJS_GetLockdownState(&ldstate);
if (status == AJ_OK && ldstate == AJS_CONSOLE_UNLOCKED) {
status = AJS_ConsoleMsgHandler(ctx, msg);
}
#endif
if (status == AJ_ERR_NO_MATCH) {
status = AJS_ServicesMsgHandler(msg);
}
if (status == AJ_ERR_NO_MATCH) {
AJ_ErrPrintf(("SessionDispatcher rejecting attempt to join unbound port %d\n", port));
status = AJ_BusReplyAcceptSession(msg, FALSE);
}
return status;
}
AJ_Status AJS_HandleJoinSessionReply(duk_context* ctx, AJ_Message* msg)
{
const char* peer = NULL;
SessionInfo* sessionInfo = NULL;
uint32_t replySerial = msg->replySerial;
uint8_t joined = FALSE;
AJS_GetGlobalStashObject(ctx, "sessions");
duk_enum(ctx, -1, DUK_ENUM_OWN_PROPERTIES_ONLY);
while (duk_next(ctx, -1, 1)) {
peer = duk_get_string(ctx, -2);
AJ_ASSERT(duk_is_object(ctx, -1));
duk_get_prop_string(ctx, -1, "info");
sessionInfo = duk_get_buffer(ctx, -1, NULL);
AJ_ASSERT(sessionInfo);
duk_pop_3(ctx);
if (sessionInfo->replySerial == replySerial) {
uint32_t sessionId;
uint32_t replyStatus;
/*
* Check if the join was successful
*/
AJ_UnmarshalArgs(msg, "uu", &replyStatus, &sessionId);
if (replyStatus == AJ_JOINSESSION_REPLY_SUCCESS) {
/*
* TODO - if we have a well-known name send a ping to get the unique name
*/
sessionInfo->sessionId = sessionId;
joined = TRUE;
}
sessionInfo->replySerial = 0;
break;
}
}
duk_pop(ctx); /* Pop the enum */
if (joined) {
/*
* TODO - we may need to initiate authentication with the remote peer
*/
AnnouncementCallbacks(ctx, peer, sessionInfo);
}
/* Pop "sessions" */
duk_pop(ctx);
return AJ_OK;
}
AJ_Status AJNS_Producer_DismissRequestHandler(AJ_BusAttachment* busAttachment, AJ_Message* msg)
{
AJ_Status status;
int32_t notificationId;
const char* appId;
AJ_Message reply;
// AJ_InfoPrintf(("In DismissMsg\n"));
status = AJ_UnmarshalArgs(msg, "i", ¬ificationId);
if (status != AJ_OK)
{
AJ_ErrPrintf(("Could not unmarshal message\n"));
return status;
}
status = AJ_MarshalReplyMsg(msg, &reply);
if (status != AJ_OK)
{
return status;
}
status = AJ_DeliverMsg(&reply);
if (status != AJ_OK)
{
return status;
}
appId = AJSVC_PropertyStore_GetValue(AJSVC_PROPERTY_STORE_APP_ID);
status = AJNS_SendDismissSignal(busAttachment, notificationId, appId);
if (status != AJ_OK)
{
return status;
}
status = AJNS_Producer_CancelNotificationById(busAttachment, notificationId);
if (status != AJ_OK)
{
return status;
}
// AJ_InfoPrintf(("***************** Message with Notification id %d dismissed successfully *****************\n", notificationId));
return status;
}
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);
}
static AJ_Status PropAccessAll(AJ_Message* msg, PropCallback* cb)
{
AJ_Status status;
AJ_Message reply;
const char* iface;
AJ_InfoPrintf(("PropAccessAll(msg=0x%p, cb=0x%p)\n", msg, cb));
status = AJ_UnmarshalArgs(msg, "s", &iface);
if (status == AJ_OK) {
status = AJ_MarshalReplyMsg(msg, &reply);
}
if (status == AJ_OK) {
status = AJ_MarshalAllPropertiesArgs(&reply, iface, cb->Get, cb->context);
}
if (status != AJ_OK) {
AJ_MarshalStatusMsg(msg, &reply, status);
}
return AJ_DeliverMsg(&reply);
}
AJ_Status AJ_PeerHandleGenSessionKey(AJ_Message* msg, AJ_Message* reply)
{
AJ_Status status;
char* remGuid;
char* locGuid;
char* nonce;
AJ_GUID guid;
AJ_GUID localGuid;
/*
* For 12 bytes of verifier, we need at least 12 * 2 characters
* to store its representation in hex (24 octets + 1 octet for \0).
* However, the KeyGen function demands a bigger buffer
* (to store 16 bytes key in addition to the 12 bytes verifier).
* Hence we allocate, the maximum of (12 * 2 + 1) and (16 + 12).
*/
char verifier[AES_KEY_LEN + VERIFIER_LEN];
/*
* Remote peer GUID, Local peer GUID and Remote peer's nonce
*/
AJ_UnmarshalArgs(msg, "sss", &remGuid, &locGuid, &nonce);
/*
* We expect arg[1] to be the local GUID
*/
status = AJ_GUID_FromString(&guid, locGuid);
if (AJ_OK == status) {
status = AJ_GetLocalGUID(&localGuid);
}
if ((status != AJ_OK) || (memcmp(&guid, &localGuid, sizeof(AJ_GUID)) != 0)) {
return AJ_MarshalErrorMsg(msg, reply, AJ_ErrRejected);
}
AJ_RandHex(authContext.nonce, sizeof(authContext.nonce), NONCE_LEN);
status = KeyGen(msg->sender, AJ_ROLE_KEY_RESPONDER, nonce, authContext.nonce, (uint8_t*)verifier, sizeof(verifier));
if (status == AJ_OK) {
AJ_MarshalReplyMsg(msg, reply);
status = AJ_MarshalArgs(reply, "ss", authContext.nonce, verifier);
} else {
status = AJ_MarshalErrorMsg(msg, reply, AJ_ErrRejected);
}
return status;
}
AJ_Status AJSUSI_VgaSetBacklightEnable_Handler(AJ_Message* msg)
{
AJ_Status status = AJ_OK;
AJ_Message reply;
uint32_t id, enable;
//Get Args
status = AJ_UnmarshalArgs(msg, "uu", &id, &enable);
if (status != AJ_OK) {
return status;
}
AJ_InfoPrintf(("%s : id=%d, enable=%d\n", __func__, id, enable));
//SUSI API
if (AJ_SusiVgaSetBacklightEnable(id, enable)) {
AJ_MarshalErrorMsg(msg, &reply, AJ_ErrFeatureNotAvailable);
return AJ_DeliverMsg(&reply);
}
//Status Reply
return SendReplyMsg(msg, NULL);
}
AJ_Status AJ_PeerHandleExchangeGUIDsReply(AJ_Message* msg)
{
AJ_Status status;
const char* guidStr;
AJ_GUID remoteGuid;
uint32_t version;
char nul = '\0';
status = AJ_UnmarshalArgs(msg, "su", &guidStr, &version);
if (status != AJ_OK) {
return status;
}
if (version != REQUIRED_AUTH_VERSION) {
PeerAuthComplete(AJ_ERR_SECURITY);
return AJ_OK;
}
AJ_GUID_FromString(&remoteGuid, guidStr);
/*
* Two name mappings to add, the well known name, and the unique name from the message.
*/
AJ_GUID_AddNameMapping(&remoteGuid, msg->sender, authContext.peerName);
/*
* Remember which peer is being authenticated
*/
authContext.peerGuid = AJ_GUID_Find(msg->sender);
/*
* Initialize SASL state machine
*/
AJ_SASL_InitContext(&authContext.sasl, authMechanisms, AJ_AUTH_RESPONDER, msg->bus->pwdCallback);
/*
* Start the authentication conversation
*/
status = AuthResponse(msg, &nul);
if (status != AJ_OK) {
PeerAuthComplete(status);
}
return status;
}
AJ_Status AJ_GUID_HandleNameHasOwnerReply(AJ_Message* msg)
{
AJ_Status status;
NameToGUID* mapping;
uint32_t hasOwner;
// AJ_InfoPrintf(("AJ_GUID_HandleNameHasOwnerReply(msg=0x%p)\n", msg));
mapping = LookupReplySerial(msg->replySerial);
if (!mapping)
{
return AJ_OK;
}
mapping->replySerial = 0;
if (msg->hdr->msgType == AJ_MSG_ERROR)
{
AJ_ErrPrintf(("AJ_GUID_HandleNameHasOwnerReply(msg=0x%p): error=%s.\n", msg, msg->error));
status = AJ_ERR_FAILURE;
AJ_GUID_DeleteNameMapping(msg->bus, mapping->uniqueName);
return status;
}
status = AJ_UnmarshalArgs(msg, "b", &hasOwner);
if (status != AJ_OK)
{
AJ_ErrPrintf(("AJ_GUID_HandleNameHasOwnerReply(msg=0x%p): Unmarshal error\n", msg));
AJ_GUID_DeleteNameMapping(msg->bus, mapping->uniqueName);
return status;
}
// Name has owner complete.
// AJ_InfoPrintf(("Name %s has owner %d\n", mapping->uniqueName, hasOwner));
if (!hasOwner)
{
AJ_GUID_DeleteNameMapping(msg->bus, mapping->uniqueName);
}
return status;
}