static AJ_Status AppHandlePing(AJ_Message* msg)
{
AJ_Status status;
AJ_Message reply;
AJ_Arg arg;
status = AJ_UnmarshalArg(msg, &arg);
if (AJ_OK == status) {
if (arg.typeId == AJ_ARG_STRING) {
AJ_Printf("Received ping request '%s'.\n", arg.val.v_string);
} else {
AJ_Printf("Unexpected arg type '%d' in ping request.\n", arg.typeId);
}
status = AJ_MarshalReplyMsg(msg, &reply);
if (AJ_OK == status) {
/*
* Just return the arg we received
*/
status = AJ_MarshalArg(&reply, &arg);
if (AJ_OK == status) {
status = AJ_DeliverMsg(&reply);
}
}
}
return status;
}
AJ_Status ExecuteAction(AJ_Message* msg, uint32_t msgId, ExecuteActionContext* context)
{
AJ_Message reply;
AJ_MarshalReplyMsg(msg, &reply);
switch (msgId) {
case EN_MYDEVICE_OVENACTION_EXEC:
case DE_AT_MYDEVICE_OVENACTION_EXEC:
{
AJ_InfoPrintf(("Starting the Oven. Execute was called\n"));
}
break;
case EN_MYDEVICE_LIGHTCONFIRM_EXEC_ACTION1:
case DE_AT_MYDEVICE_LIGHTCONFIRM_EXEC_ACTION1:
{
AJ_InfoPrintf(("Execute Action1 was called\n"));
}
break;
case EN_MYDEVICE_LIGHTCONFIRM_EXEC_ACTION2:
case DE_AT_MYDEVICE_LIGHTCONFIRM_EXEC_ACTION2:
{
AJ_InfoPrintf(("Execute Action2 was called\n"));
}
break;
case EN_MYDEVICE_LIGHTCONFIRM_EXEC_ACTION3:
case DE_AT_MYDEVICE_LIGHTCONFIRM_EXEC_ACTION3:
{
AJ_InfoPrintf(("Execute Action3 was called\n"));
}
break;
case EN_MYDEVICE_AREYOUSURE_EXEC_ACTION1:
case DE_AT_MYDEVICE_AREYOUSURE_EXEC_ACTION1:
{
AJ_InfoPrintf(("Execute Action1 was called\n")); addDismissSignal(context, MYDEVICE_NOTIFICATION_ACTION_AREYOUSURE_SIGNAL_DISMISS);
}
break;
case EN_MYDEVICE_AREYOUSURE_EXEC_ACTION2:
case DE_AT_MYDEVICE_AREYOUSURE_EXEC_ACTION2:
{
AJ_MarshalErrorMsg(msg, &reply, AJ_ErrServiceUnknown);
}
break;
case EN_MYDEVICE_AREYOUSURE_EXEC_ACTION3:
case DE_AT_MYDEVICE_AREYOUSURE_EXEC_ACTION3:
{
AJ_MarshalErrorMsg(msg, &reply, AJ_ErrServiceUnknown);
}
break;
}
return AJ_DeliverMsg(&reply);
}
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;
}
AJSVC_ServiceStatus EventsAndActionsMessageProcessor(AJ_BusAttachment* busAttachment, AJ_Message* msg, AJ_Status* msgStatus)
{
AJ_Message reply;
AJSVC_ServiceStatus serviceStatus = AJSVC_SERVICE_STATUS_HANDLED;
switch (msg->msgId) {
case EVENTSANDACTIONS_GET_PROP:
*msgStatus = AJ_BusPropGet(msg, EventsAndActionsPropGetHandler, NULL);
break;
case EVENTSANDACTIONS_SET_PROP:
*msgStatus = AJ_BusPropSet(msg, EventsAndActionsPropSetHandler, NULL);
break;
case ACTIONS_SETMODETOAUTO:
case ACTIONS_SETMODETOCOOL:
case ACTIONS_SETMODETOHEAT:
case ACTIONS_SETMODETOFAN:
case ACTIONS_SETMODETOOFF:
AJ_MarshalReplyMsg(msg, &reply);
setCurrentMode((msg->msgId & 0xFF) - (ACTIONS_SETMODETOAUTO & 0xFF));
*msgStatus = AJ_DeliverMsg(&reply);
break;
default:
serviceStatus = AJSVC_SERVICE_STATUS_NOT_HANDLED;
break;
}
return serviceStatus;
}
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 AJOBS_GetScanInfoHandler(AJ_Message* msg)
{
AJ_Status status = AJ_OK;
AJ_Message reply;
AJ_Arg array;
AJ_Arg structure;
uint32_t elapsed;
AJ_InfoPrintf(("Handling GetScanInfo request\n"));
status = AJ_MarshalReplyMsg(msg, &reply);
if (status != AJ_OK) {
return status;
}
elapsed = AJ_GetElapsedTime(AJOBS_GetLastScanTime(), TRUE);
if (elapsed > 0) {
elapsed /= 60000;
}
status = AJ_MarshalArgs(&reply, "q", (uint16_t) elapsed);
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalContainer(&reply, &array, AJ_ARG_ARRAY);
if (status != AJ_OK) {
return status;
}
int i = 0;
for (; i < AJOBS_GetScanInfoCount(); ++i) {
status = AJ_MarshalContainer(&reply, &structure, AJ_ARG_STRUCT);
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalArgs(&reply, "s", (AJOBS_GetScanInfos())[i].ssid);
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalArgs(&reply, "n", (AJOBS_GetScanInfos())[i].authType);
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalCloseContainer(&reply, &structure);
if (status != AJ_OK) {
return status;
}
}
status = AJ_MarshalCloseContainer(&reply, &array);
if (status != AJ_OK) {
return status;
}
status = AJ_DeliverMsg(&reply);
if (status != AJ_OK) {
return status;
}
return status;
}
AJ_Status AJ_BusReplyAcceptSession(AJ_Message* msg, uint32_t accept)
{
AJ_Message reply;
AJ_InfoPrintf(("AJ_BusReplyAcceptSession(msg=0x%p, accept=%d.)\n", msg, accept));
AJ_MarshalReplyMsg(msg, &reply);
AJ_MarshalArgs(&reply, "b", accept);
return AJ_DeliverMsg(&reply);
}
static AJ_Status AppHandleOnOff(AJ_Message* msg, uint8_t on)
{
AJ_Message reply;
AJ_AlwaysPrintf(("AppHandleOnOff(%u)\n", on));
DUE_led(on);
AJ_MarshalReplyMsg(msg, &reply);
return AJ_DeliverMsg(&reply);
}
AJ_Status ExecuteAction(AJ_Message* msg, uint32_t msgId, ExecuteActionContext* context)
{
AJ_Message reply;
AJ_MarshalReplyMsg(msg, &reply);
switch (msgId) {
//EXECUTE_ACTION_GO_HERE
}
return AJ_DeliverMsg(&reply);
}
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;
}
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 AppHandlePing(AJ_Message* msg)
{
AJ_Message reply;
AJ_Arg arg;
AJ_UnmarshalArg(msg, &arg);
AJ_MarshalReplyMsg(msg, &reply);
/*
* Just return the arg we received
*/
AJ_MarshalArg(&reply, &arg);
return AJ_DeliverMsg(&reply);
}
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 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;
}
static AJ_Status PropAccess(AJ_Message* msg, PropCallback* cb, uint8_t op)
{
AJ_Status status;
AJ_Message reply;
uint32_t propId;
const char* sig;
AJ_InfoPrintf(("PropAccess(msg=0x%p, cb=0x%p, op=%d.)\n", msg, cb, op));
/*
* Find out which property is being accessed and whether the access is a GET or SET
*/
status = AJ_UnmarshalPropertyArgs(msg, &propId, &sig);
if (status == AJ_OK) {
AJ_MarshalReplyMsg(msg, &reply);
/*
* Callback to let the application marshal or unmarshal the value
*/
if (op == AJ_PROP_GET) {
AJ_MarshalVariant(&reply, sig);
status = cb->Get(&reply, propId, cb->context);
} else {
const char* variant;
AJ_UnmarshalVariant(msg, &variant);
/*
* Check that the value has the expected signature
*/
if (strcmp(sig, variant) == 0) {
status = cb->Set(msg, propId, cb->context);
} else {
AJ_InfoPrintf(("PropAccess(): AJ_ERR_SIGNATURE\n"));
status = AJ_ERR_SIGNATURE;
}
}
}
if (status != AJ_OK) {
AJ_MarshalStatusMsg(msg, &reply, status);
}
return AJ_DeliverMsg(&reply);
}
static AJ_Status ExecuteAction(AJ_Message* msg, uint8_t action, void* context)
{
AJS_Widget* widget = (AJS_Widget*)objectList[OBJ_INDEX(msg->msgId)].context;
AJ_Status status;
AJ_Message reply;
/*
* Need to make a clone of the message and close the original
*/
msg = AJS_CloneAndCloseMessage(widget->dukCtx, msg);
if (!msg) {
return AJ_ERR_RESOURCES;
}
/*
* Call into JavaScript object to perform action
*/
status = AJS_CP_ExecuteAction(widget, action);
if (status == AJ_OK) {
AJ_MarshalReplyMsg(msg, &reply);
} else {
AJ_MarshalStatusMsg(msg, &reply, status);
}
return AJ_DeliverMsg(&reply);
}
AJ_Status AJ_PeerHandleExchangeGroupKeys(AJ_Message* msg, AJ_Message* reply)
{
AJ_Status status;
AJ_Arg key;
AJ_UnmarshalArg(msg, &key);
/*
* We expect the key to be 16 bytes
*/
if (key.len != AES_KEY_LEN) {
status = AJ_ERR_INVALID;
} else {
status = AJ_SetGroupKey(msg->sender, key.val.v_byte);
}
if (status == AJ_OK) {
uint8_t groupKey[AES_KEY_LEN];
AJ_MarshalReplyMsg(msg, reply);
AJ_GetGroupKey(NULL, groupKey);
status = AJ_MarshalArg(reply, AJ_InitArg(&key, AJ_ARG_BYTE, AJ_ARRAY_FLAG, groupKey, sizeof(groupKey)));
} else {
status = AJ_MarshalErrorMsg(msg, reply, AJ_ErrRejected);
}
return status;
}
AJ_Status AJ_RunAllJoynService(AJ_BusAttachment* bus, AllJoynConfiguration* config)
{
uint8_t connected = FALSE;
AJ_Status status = AJ_OK;
while (TRUE) {
AJ_Time start = { 0, 0 };
AJ_Message msg;
uint32_t now;
// get the next timeout
//Timer* timer = GetNextTimeout();
uint32_t next;
// wait forever
uint32_t timeout = (uint32_t) -1;
if (!connected) {
status = AJ_StartService2(
bus,
config->daemonName, config->connect_timeout, config->connected,
config->session_port, config->service_name, config->flags, config->opts);
if (status != AJ_OK) {
continue;
}
AJ_InfoPrintf(("StartService returned AJ_OK\n"));
AJ_InfoPrintf(("Connected to Daemon:%s\n", AJ_GetUniqueName(bus)));
connected = TRUE;
/* Register a callback for providing bus authentication password */
AJ_BusSetPasswordCallback(bus, config->password_callback);
/* Configure timeout for the link to the daemon bus */
AJ_SetBusLinkTimeout(bus, config->link_timeout);
if (config->connection_handler != NULL) {
(config->connection_handler)(connected);
}
}
// absolute time in milliseconds
now = AJ_GetElapsedTime(&start, FALSE);
next = RunExpiredTimers(now);
if (next != (uint32_t) -1) {
// if no timers running, wait forever
timeout = next;
}
status = AJ_UnmarshalMsg(bus, &msg, min(500, timeout));
if (AJ_ERR_TIMEOUT == status && AJ_ERR_LINK_TIMEOUT == AJ_BusLinkStateProc(bus)) {
status = AJ_ERR_READ;
}
if (status == AJ_ERR_TIMEOUT) {
// go back around and handle the expired timers
continue;
}
if (status == AJ_OK) {
uint8_t handled = FALSE;
const MessageHandlerEntry* message_entry = config->message_handlers;
const PropHandlerEntry* prop_entry = config->prop_handlers;
// check the user's handlers first. ANY message that AllJoyn can handle is override-able.
while (handled != TRUE && message_entry->msgid != 0) {
if (message_entry->msgid == msg.msgId) {
if (msg.hdr->msgType == AJ_MSG_METHOD_CALL) {
// build a method reply
AJ_Message reply;
status = AJ_MarshalReplyMsg(&msg, &reply);
if (status == AJ_OK) {
status = (message_entry->handler)(&msg, &reply);
}
if (status == AJ_OK) {
status = AJ_DeliverMsg(&reply);
}
} else {
// call the handler!
status = (message_entry->handler)(&msg, NULL);
}
handled = TRUE;
}
++message_entry;
}
// we need to check whether this is a property getter or setter.
// these are stored in an array because multiple getters and setters can exist if running more than one bus object
while (handled != TRUE && prop_entry->msgid != 0) {
if (prop_entry->msgid == msg.msgId) {
// extract the method from the ID; GetProperty or SetProperty
uint32_t method = prop_entry->msgid & 0x000000FF;
if (method == AJ_PROP_GET) {
status = AJ_BusPropGet(&msg, prop_entry->callback, prop_entry->context);
} else if (method == AJ_PROP_SET) {
status = AJ_BusPropSet(&msg, prop_entry->callback, prop_entry->context);
} else {
// this should never happen!!!
AJ_ASSERT(!"Invalid property method");
}
handled = TRUE;
}
++prop_entry;
}
// handler not found!
if (handled == FALSE) {
if (msg.msgId == AJ_METHOD_ACCEPT_SESSION) {
uint8_t accepted = (config->acceptor)(&msg);
status = AJ_BusReplyAcceptSession(&msg, accepted);
} else {
status = AJ_BusHandleBusMessage(&msg);
}
}
// Any received packets indicates the link is active, so call to reinforce the bus link state
AJ_NotifyLinkActive();
}
/*
* Unarshaled messages must be closed to free resources
*/
AJ_CloseMsg(&msg);
if (status == AJ_ERR_READ) {
AJ_InfoPrintf(("AllJoyn disconnect\n"));
AJ_InfoPrintf(("Disconnected from Daemon:%s\n", AJ_GetUniqueName(bus)));
AJ_Disconnect(bus);
connected = FALSE;
if (config->connection_handler != NULL) {
(config->connection_handler)(connected);
}
/*
* Sleep a little while before trying to reconnect
*/
AJ_Sleep(10 * 1000);
}
}
// this will never actually return!
return AJ_OK;
}
AJ_Status AJ_HandleIntrospectRequest(const AJ_Message* msg, AJ_Message* reply)
{
AJ_Status status = AJ_OK;
const AJ_Object* obj = objectLists[AJ_APP_ID_FLAG];
uint32_t children = 0;
AJ_Object parent;
WriteContext context;
/*
* Return an error if there are no local objects
*/
if (!obj) {
return AJ_MarshalErrorMsg(msg, reply, AJ_ErrServiceUnknown);
}
/*
* Find out which object we are introspecting. There are two possibilities:
*
* - The request has a complete object path to one of the application objects.
* - The request has a path to a parent object of one or more application objects where the
* parent itself is just a place-holder in the object hierarchy.
*/
for (; obj->path != NULL; ++obj) {
if (strcmp(msg->objPath, obj->path) == 0) {
break;
}
if (ChildPath(msg->objPath, obj->path, NULL)) {
++children;
}
}
/*
* If there was not a direct match but the requested node has children we create
* a temporary AJ_Object for the parent and introspect that object.
*/
if ((obj->path == NULL) && children) {
parent.flags = 0;
parent.path = msg->objPath;
parent.interfaces = NULL;
obj = &parent;
}
/*
* Skip objects that are hidden or disabled
*/
if (obj->path && !(obj->flags & (AJ_OBJ_FLAG_HIDDEN | AJ_OBJ_FLAG_DISABLED))) {
/*
* First pass computes the size of the XML string
*/
context.len = 0;
status = GenXML(SizeXML, &context.len, obj, objectLists[1]);
if (status != AJ_OK) {
AJ_ErrPrintf(("AJ_HandleIntrospectRequest(): Failed to generate XML. status=%s", AJ_StatusText(status)));
return status;
}
/*
* Second pass marshals the XML
*/
AJ_InfoPrintf(("AJ_HandleIntrospectRequest() %d bytes of XML\n", context.len));
AJ_MarshalReplyMsg(msg, reply);
/*
* Do a partial delivery
*/
status = AJ_DeliverMsgPartial(reply, context.len + 5);
/*
* Marshal the string length
*/
if (status == AJ_OK) {
status = AJ_MarshalRaw(reply, &context.len, 4);
}
if (status == AJ_OK) {
uint8_t nul = 0;
context.status = AJ_OK;
context.reply = reply;
GenXML(WriteXML, &context, obj, objectLists[1]);
status = context.status;
if (status == AJ_OK) {
/*
* Marshal the terminating NUL
*/
status = AJ_MarshalRaw(reply, &nul, 1);
}
}
} else {
/*
* Return a ServiceUnknown error response
*/
AJ_WarnPrintf(("AJ_HandleIntrospectRequest() NO MATCH for %s\n", msg->objPath));
AJ_MarshalErrorMsg(msg, reply, AJ_ErrServiceUnknown);
}
return status;
}
AJ_Status AJ_ProcessInternal(AJ_Message* msg, IdentifyFunction identifyFunction)
{
AJ_Status status = AJ_OK;
switch (msg->msgId) {
case APP_SET_WIFI:
{
uint32_t active = AJ_GetActive();
uint32_t index;
char* ssid;
char* password;
uint32_t auth;
uint32_t encryption;
status = AJ_UnmarshalArgs(msg, "ussuu", &index, &ssid, &password, &auth, &encryption);
if (status == AJ_OK) {
status = AJ_SaveWifiProfile(index, ssid, password, auth, encryption);
if (status == AJ_OK) {
AJ_Message reply;
AJ_MarshalReplyMsg(msg, &reply);
status = AJ_DeliverMsg(&reply);
} else {
AJ_Message reply;
AJ_MarshalErrorMsg(msg, &reply, "Invalid parameter");
status = AJ_DeliverMsg(&reply);
}
}
// if we are modifying the current profile, we need to
if (status == AJ_OK && index == active) {
status = AJ_ERR_RESTART;
}
break;
}
case APP_GET_WIFI:
{
uint32_t index;
status = AJ_UnmarshalArgs(msg, "u", &index);
if (status == AJ_OK) {
const AJ_ConnectionProfile* config = AJ_ReadProfile(index);
switch (config->type) {
case PROFILE_TYPE_WIFI:
{
const AJ_WifiProfile* profile = &(config->wifi);
AJ_Message reply;
AJ_MarshalReplyMsg(msg, &reply);
AJ_MarshalArgs(&reply, "ssuu", profile->ssid, profile->password, &profile->auth, &profile->encryption);
status = AJ_DeliverMsg(&reply);
break;
}
default:
status = AJ_ERR_INVALID;
break;
}
}
if (status != AJ_OK) {
AJ_Message reply;
AJ_MarshalErrorMsg(msg, &reply, "Invalid parameter");
status = AJ_DeliverMsg(&reply);
}
break;
}
case APP_IDENTIFY:
{
AJ_Message reply;
char name[80];
// limit the output to 80 bytes
(*identifyFunction)(name, sizeof(name));
name[sizeof(name) - 1] = '\0';
AJ_MarshalReplyMsg(msg, &reply);
AJ_MarshalArgs(&reply, "s", name);
status = AJ_DeliverMsg(&reply);
break;
}
case APP_MAX_PROFILE:
{
AJ_Message reply;
uint32_t max = MAX_PROFILES;
AJ_MarshalReplyMsg(msg, &reply);
AJ_MarshalArgs(&reply, "u", &max);
status = AJ_DeliverMsg(&reply);
break;
}
case APP_CLEAR:
{
AJ_Message reply;
uint32_t index;
status = AJ_UnmarshalArgs(msg, "u", &index);
if (index == AJ_GetActive()) {
AJ_MarshalErrorMsg(msg, &reply, "Cannot clear active profile");
status = AJ_DeliverMsg(&reply);
} else {
AJ_ClearConfig(index);
AJ_MarshalReplyMsg(msg, &reply);
status = AJ_DeliverMsg(&reply);
}
break;
}
case APP_CONNECT:
{
AJ_Message reply;
uint32_t index;
status = AJ_UnmarshalArgs(msg, "u", &index);
if (status == AJ_OK) {
status = AJ_SetActive(index);
if (status == AJ_OK) {
AJ_MarshalReplyMsg(msg, &reply);
status = AJ_DeliverMsg(&reply);
}
}
if (status != AJ_OK) {
AJ_MarshalErrorMsg(msg, &reply, "Invalid parameter");
status = AJ_DeliverMsg(&reply);
} else {
status = AJ_ERR_RESTART;
}
break;
}
default:
status = AJ_ERR_UNEXPECTED;
break;
}
return status;
}
AJ_Status AJCFG_ResetConfigurationsHandler(AJ_Message* msg)
{
AJ_Status status = AJ_OK;
AJ_Arg array;
AJ_Message reply;
char* key;
char* language;
int8_t langIndex = AJSVC_PROPERTY_STORE_ERROR_LANGUAGE_INDEX;
uint8_t numOfDeletedItems = 0;
uint8_t errorReply = FALSE;
AJ_InfoPrintf(("Handling ResetConfigurations request\n"));
status = AJ_UnmarshalArgs(msg, "s", &language);
if (status != AJ_OK) {
goto Exit;
}
AJ_InfoPrintf(("Lang=%s\n", language));
errorReply = !AJSVC_IsLanguageSupported(msg, &reply, language, &langIndex);
if (!errorReply) {
status = AJ_UnmarshalContainer(msg, &array, AJ_ARG_ARRAY);
if (status != AJ_OK) {
goto Exit;
}
while (1) {
status = AJ_UnmarshalArgs(msg, "s", &key);
if (status != AJ_OK) {
break;
}
AJ_InfoPrintf(("Key=%s\n", key));
status = AJSVC_PropertyStore_Reset(key, langIndex);
if (status == AJ_OK) {
numOfDeletedItems++;
} else if (status == AJ_ERR_INVALID) {
if (!errorReply) {
AJ_MarshalErrorMsg(msg, &reply, AJSVC_ERROR_INVALID_VALUE);
errorReply = TRUE;
}
} else if (status == AJ_ERR_FAILURE) {
if (!errorReply) {
AJ_MarshalErrorMsg(msg, &reply, AJSVC_ERROR_UPDATE_NOT_ALLOWED);
errorReply = TRUE;
}
}
}
if (status != AJ_OK && status != AJ_ERR_NO_MORE) {
goto Exit;
}
status = AJ_UnmarshalCloseContainer(msg, &array);
if (status != AJ_OK) {
goto Exit;
}
}
if (!errorReply) {
status = AJ_MarshalReplyMsg(msg, &reply);
if (status != AJ_OK) {
goto Exit;
}
}
status = AJ_DeliverMsg(&reply);
if (status != AJ_OK) {
goto Exit;
}
Exit:
if (numOfDeletedItems) {
if (errorReply) {
AJSVC_PropertyStore_LoadAll(); // Discard partial successful deletions
} else {
AJSVC_PropertyStore_SaveAll();
AJ_AboutSetShouldAnnounce();
}
}
return status;
}
AJ_Status AJ_BusHandleBusMessage(AJ_Message* msg)
{
AJ_Status status = AJ_OK;
AJ_BusAttachment* bus = msg->bus;
char* languageTag;
AJ_Message reply;
AJ_InfoPrintf(("AJ_BusHandleBusMessage(msg=0x%p)\n", msg));
memset(&reply, 0, sizeof(AJ_Message));
/*
* Check we actually have a message to handle
*/
if (!msg->hdr) {
return AJ_OK;
}
switch (msg->msgId) {
case AJ_METHOD_PING:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_METHOD_PING\n"));
status = AJ_MarshalReplyMsg(msg, &reply);
break;
case AJ_METHOD_GET_MACHINE_ID:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_METHOD_GET_MACHINE_ID\n"));
status = HandleGetMachineId(msg, &reply);
break;
case AJ_METHOD_INTROSPECT:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_METHOD_INTROSPECT\n"));
status = AJ_HandleIntrospectRequest(msg, &reply, NULL);
break;
case AJ_METHOD_GET_DESCRIPTION_LANG:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_METHOD_GET_DESCRIPTION_LANG\n"));
status = AJ_HandleGetDescriptionLanguages(msg, &reply);
break;
case AJ_METHOD_INTROSPECT_WITH_DESC:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_METHOD_INTROSPECT_WITH_DESC\n"));
AJ_UnmarshalArgs(msg, "s", &languageTag);
status = AJ_HandleIntrospectRequest(msg, &reply, languageTag);
break;
case AJ_METHOD_EXCHANGE_GUIDS:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_METHOD_EXCHANGE_GUIDS\n"));
status = AJ_PeerHandleExchangeGUIDs(msg, &reply);
break;
case AJ_METHOD_GEN_SESSION_KEY:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_METHOD_GEN_SESSION_KEY\n"));
status = AJ_PeerHandleGenSessionKey(msg, &reply);
break;
case AJ_METHOD_EXCHANGE_GROUP_KEYS:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_METHOD_EXCHANGE_GROUP_KEYS\n"));
status = AJ_PeerHandleExchangeGroupKeys(msg, &reply);
break;
case AJ_METHOD_EXCHANGE_SUITES:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_METHOD_EXCHANGE_SUITES\n"));
status = AJ_PeerHandleExchangeSuites(msg, &reply);
break;
case AJ_METHOD_KEY_EXCHANGE:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_METHOD_KEY_EXCHANGE\n"));
status = AJ_PeerHandleKeyExchange(msg, &reply);
break;
case AJ_METHOD_KEY_AUTHENTICATION:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_METHOD_KEY_AUTHENTICATION\n"));
status = AJ_PeerHandleKeyAuthentication(msg, &reply);
break;
case AJ_REPLY_ID(AJ_METHOD_EXCHANGE_GUIDS):
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_REPLY_ID(AJ_METHOD_EXCHANGE_GUIDS)\n"));
status = AJ_PeerHandleExchangeGUIDsReply(msg);
break;
case AJ_REPLY_ID(AJ_METHOD_EXCHANGE_SUITES):
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_REPLY_ID(AJ_METHOD_EXCHANGE_SUITES)\n"));
status = AJ_PeerHandleExchangeSuitesReply(msg);
break;
case AJ_REPLY_ID(AJ_METHOD_KEY_EXCHANGE):
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_REPLY_ID(AJ_METHOD_KEY_EXCHANGE)\n"));
status = AJ_PeerHandleKeyExchangeReply(msg);
break;
case AJ_REPLY_ID(AJ_METHOD_KEY_AUTHENTICATION):
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_REPLY_ID(AJ_METHOD_KEY_AUTHENTICATION)\n"));
status = AJ_PeerHandleKeyAuthenticationReply(msg);
break;
case AJ_REPLY_ID(AJ_METHOD_GEN_SESSION_KEY):
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_REPLY_ID(AJ_METHOD_GEN_SESSION_KEY)\n"));
status = AJ_PeerHandleGenSessionKeyReply(msg);
break;
case AJ_REPLY_ID(AJ_METHOD_EXCHANGE_GROUP_KEYS):
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_REPLY_ID(AJ_METHOD_EXCHANGE_GROUP_KEYS)\n"));
status = AJ_PeerHandleExchangeGroupKeysReply(msg);
break;
case AJ_REPLY_ID(AJ_METHOD_CANCEL_SESSIONLESS):
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_REPLY_ID(AJ_METHOD_CANCEL_SESSIONLESS)\n"));
// handle return code here
status = AJ_OK;
break;
case AJ_SIGNAL_SESSION_JOINED:
case AJ_SIGNAL_NAME_ACQUIRED:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_SIGNAL_{SESSION_JOINED|NAME_ACQUIRED}\n"));
// nothing to do here
status = AJ_OK;
break;
case AJ_REPLY_ID(AJ_METHOD_CANCEL_ADVERTISE):
case AJ_REPLY_ID(AJ_METHOD_ADVERTISE_NAME):
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_REPLY_ID(AJ_METHOD_{CANCEL_ADVERTISE|ADVERTISE_NAME})\n"));
if (msg->hdr->msgType == AJ_MSG_ERROR) {
status = AJ_ERR_FAILURE;
}
break;
case AJ_METHOD_ABOUT_GET_PROP:
return AJ_AboutHandleGetProp(msg);
case AJ_METHOD_ABOUT_GET_ABOUT_DATA:
status = AJ_AboutHandleGetAboutData(msg, &reply);
break;
case AJ_METHOD_ABOUT_GET_OBJECT_DESCRIPTION:
status = AJ_AboutHandleGetObjectDescription(msg, &reply);
break;
case AJ_METHOD_ABOUT_ICON_GET_PROP:
return AJ_AboutIconHandleGetProp(msg);
case AJ_METHOD_ABOUT_ICON_GET_URL:
status = AJ_AboutIconHandleGetURL(msg, &reply);
break;
case AJ_METHOD_ABOUT_ICON_GET_CONTENT:
status = AJ_AboutIconHandleGetContent(msg, &reply);
break;
#ifdef ANNOUNCE_BASED_DISCOVERY
case AJ_SIGNAL_ABOUT_ANNOUNCE:
status = AJ_AboutHandleAnnounce(msg, NULL, NULL, NULL, NULL);
break;
#endif
default:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): default\n"));
if (msg->hdr->msgType == AJ_MSG_METHOD_CALL) {
status = AJ_MarshalErrorMsg(msg, &reply, AJ_ErrRejected);
}
break;
}
if ((status == AJ_OK) && (msg->hdr->msgType == AJ_MSG_METHOD_CALL)) {
status = AJ_DeliverMsg(&reply);
}
/*
* Check if there is anything to announce
*/
if (status == AJ_OK) {
AJ_AboutAnnounce(bus);
}
return status;
}
AJ_Status AJOBS_ConfigureWiFiHandler(AJ_Message* msg)
{
AJ_Status status = AJ_OK;
AJ_Message reply;
AJOBS_Info newInfo;
char* ssid;
char* pc;
size_t ssidLen;
size_t pcLen;
int16_t retVal;
// Set provided network configuration
AJ_InfoPrintf(("Handling ConfigureWiFi request\n"));
status = AJ_UnmarshalArgs(msg, "ssn", &ssid, &pc, &newInfo.authType);
if (status != AJ_OK) {
return status;
}
if ((int8_t)newInfo.authType >= AJOBS_AUTH_TYPE_MAX_OF_WIFI_AUTH_TYPE || (int8_t)newInfo.authType <= AJOBS_AUTH_TYPE_MIN_OF_WIFI_AUTH_TYPE) {
AJ_ErrPrintf(("Unknown authentication type %d\n", newInfo.authType));
status = AJ_MarshalErrorMsg(msg, &reply, AJSVC_ERROR_INVALID_VALUE);
if (status != AJ_OK) {
return status;
}
status = AJ_DeliverMsg(&reply);
if (status != AJ_OK) {
return status;
}
return status;
}
ssidLen = min(strlen(ssid), AJOBS_SSID_MAX_LENGTH);
strncpy(newInfo.ssid, ssid, AJOBS_SSID_MAX_LENGTH);
newInfo.ssid[ssidLen] = '\0';
pcLen = min(strlen(pc), AJOBS_PASSCODE_MAX_LENGTH);
strncpy(newInfo.pc, pc, AJOBS_PASSCODE_MAX_LENGTH);
newInfo.pc[pcLen] = '\0';
AJ_InfoPrintf(("Got new info for %s with passcode=%s and auth=%d\n", newInfo.ssid, newInfo.pc, newInfo.authType));
retVal = 1;
status = AJ_MarshalReplyMsg(msg, &reply);
if (status != AJ_OK) {
return status;
}
status = AJ_MarshalArgs(&reply, "n", retVal);
if (status != AJ_OK) {
return status;
}
status = AJ_DeliverMsg(&reply);
if (status != AJ_OK) {
return status;
}
newInfo.state = AJOBS_STATE_CONFIGURED_NOT_VALIDATED;
status = AJOBS_SetInfo(&newInfo);
if (status == AJ_OK) {
// Change state to CONFIGURED
AJOBS_SetState(newInfo.state);
}
return status;
}
AJ_Status AJ_BusHandleBusMessage(AJ_Message* msg)
{
AJ_Status status = AJ_OK;
char* name;
char* oldOwner;
char* newOwner;
AJ_Message reply;
AJ_InfoPrintf(("AJ_BusHandleBusMessage(msg=0x%p)\n", msg));
/*
* Check we actually have a message to handle
*/
if (!msg->hdr) {
return AJ_OK;
}
switch (msg->msgId) {
case AJ_METHOD_PING:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_METHOD_PING\n"));
status = AJ_MarshalReplyMsg(msg, &reply);
break;
case AJ_METHOD_GET_MACHINE_ID:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_METHOD_GET_MACHINE_ID\n"));
status = HandleGetMachineId(msg, &reply);
break;
case AJ_METHOD_INTROSPECT:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_METHOD_INTROSPECT\n"));
status = AJ_HandleIntrospectRequest(msg, &reply);
break;
case AJ_METHOD_EXCHANGE_GUIDS:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_METHOD_EXCHANGE_GUIDS\n"));
status = AJ_PeerHandleExchangeGUIDs(msg, &reply);
break;
case AJ_METHOD_GEN_SESSION_KEY:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_METHOD_GEN_SESSION_KEY\n"));
status = AJ_PeerHandleGenSessionKey(msg, &reply);
break;
case AJ_METHOD_EXCHANGE_GROUP_KEYS:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_METHOD_EXCHANGE_GROUP_KEYS\n"));
status = AJ_PeerHandleExchangeGroupKeys(msg, &reply);
break;
case AJ_METHOD_AUTH_CHALLENGE:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_METHOD_AUTH_CHALLENGE\n"));
status = AJ_PeerHandleAuthChallenge(msg, &reply);
break;
case AJ_REPLY_ID(AJ_METHOD_EXCHANGE_GUIDS):
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_REPLY_ID(AJ_METHOD_EXCHANGE_GUIDS)\n"));
status = AJ_PeerHandleExchangeGUIDsReply(msg);
break;
case AJ_REPLY_ID(AJ_METHOD_AUTH_CHALLENGE):
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_REPLY_ID(AJ_METHOD_AUTH_CHALLENGE)\n"));
status = AJ_PeerHandleAuthChallengeReply(msg);
break;
case AJ_REPLY_ID(AJ_METHOD_GEN_SESSION_KEY):
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_REPLY_ID(AJ_METHOD_GEN_SESSION_KEY)\n"));
status = AJ_PeerHandleGenSessionKeyReply(msg);
break;
case AJ_REPLY_ID(AJ_METHOD_EXCHANGE_GROUP_KEYS):
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_REPLY_ID(AJ_METHOD_EXCHANGE_GROUP_KEYS)\n"));
status = AJ_PeerHandleExchangeGroupKeysReply(msg);
break;
case AJ_REPLY_ID(AJ_METHOD_CANCEL_SESSIONLESS):
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_REPLY_ID(AJ_METHOD_CANCEL_SESSIONLESS)\n"));
// handle return code here
status = AJ_OK;
break;
case AJ_SIGNAL_SESSION_JOINED:
case AJ_SIGNAL_NAME_ACQUIRED:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_SIGNAL_{SESSION_JOINED|NAME_ACQUIRED}\n"));
// nothing to do here
status = AJ_OK;
break;
case AJ_REPLY_ID(AJ_METHOD_ADD_MATCH):
case AJ_REPLY_ID(AJ_METHOD_REMOVE_MATCH):
case AJ_REPLY_ID(AJ_METHOD_CANCEL_ADVERTISE):
case AJ_REPLY_ID(AJ_METHOD_ADVERTISE_NAME):
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_REPLY_ID(AJ_METHOD_{ADD_MATCH|CANCEL_ADVERTISE|ADVERTISE_NAME})\n"));
if (msg->hdr->msgType == AJ_MSG_ERROR) {
status = AJ_ERR_FAILURE;
}
break;
case AJ_SIGNAL_NAME_OWNER_CHANGED:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): AJ_SIGNAL_NAME_OWNER_CHANGED)\n"));
AJ_UnmarshalArgs(msg, "sss", &name, &oldOwner, &newOwner);
if (newOwner && oldOwner && newOwner[0] == '\0') {
AJ_GUID_DeleteNameMapping(oldOwner);
}
/*
* Reset so the application can handle this too
*/
status = AJ_ResetArgs(msg);
break;
default:
AJ_InfoPrintf(("AJ_BusHandleBusMessage(): default\n"));
if (msg->hdr->msgType == AJ_MSG_METHOD_CALL) {
status = AJ_MarshalErrorMsg(msg, &reply, AJ_ErrRejected);
}
break;
}
if ((status == AJ_OK) && (msg->hdr->msgType == AJ_MSG_METHOD_CALL)) {
status = AJ_DeliverMsg(&reply);
}
return status;
}
static AJ_Status SetWidgetProp(AJ_Message* msg)
{
AJS_Widget* widget = NULL;
AJ_Message reply;
AJ_Status status;
uint32_t propId;
const char* vsig;
AJ_InfoPrintf(("SetWidgetProp %s\n", msg->objPath));
status = AJ_UnmarshalPropertyArgs(msg, &propId, &vsig);
/*
* Two levels of variant because Set always uses a variant and the property type for the widget
* is not known until runtime so is specified as a variant type in the property widget interface.
*/
if (status == AJ_OK) {
status = AJ_UnmarshalVariant(msg, &vsig);
}
if (status == AJ_OK) {
status = AJ_UnmarshalVariant(msg, &vsig);
}
if (status == AJ_OK) {
widget = (AJS_Widget*)objectList[OBJ_INDEX(propId)].context;
/*
* Value is the only property that is writeable. Figure out how to unmarshal it.
*/
switch (widget->property.wdt.signature[0]) {
case 'i':
status = AJ_UnmarshalArgs(msg, "i", &widget->property.val.i);
break;
case 'q':
status = AJ_UnmarshalArgs(msg, "q", &widget->property.val.q);
break;
case 'b':
status = AJ_UnmarshalArgs(msg, "b", &widget->property.val.b);
break;
case 'd':
status = AJ_UnmarshalArgs(msg, "d", &widget->property.val.d);
break;
case 's':
status = AJ_UnmarshalArgs(msg, "s", &widget->property.val.s);
break;
default:
{
AJ_Arg st;
uint16_t propertyType;
status = AJ_UnmarshalContainer(msg, &st, AJ_ARG_STRUCT);
if (status != AJ_OK) {
break;
}
status = AJ_UnmarshalArgs(msg, "q", &propertyType);
if (status != AJ_OK) {
break;
}
/*
* For some reason the implementors of the control panel service used 0/1 to
* distingsuish between date/time rather than 1/2. Incrementing the property type
* fixes this oversight.
*/
if (++propertyType != widget->property.wdt.propertyType) {
status = AJ_ERR_INVALID;
break;
}
if (propertyType == TIME_VALUE_PROPERTY) {
status = AJ_UnmarshalArgs(msg, "(qqq)", &widget->property.val.time.hour, &widget->property.val.time.minute, &widget->property.val.time.second);
} else {
status = AJ_UnmarshalArgs(msg, "(qqq)", &widget->property.val.date.mDay, &widget->property.val.date.month, &widget->property.val.date.fullYear);
}
/*
* Signal that the value has been changed
*/
AJS_CPS_SignalValueChanged(AJS_GetBusAttachment(), widget);
if (status == AJ_OK) {
status = AJ_UnmarshalCloseContainer(msg, &st);
}
}
break;
}
} else {
return AJ_ERR_RESOURCES;
}
/*
* Need to make a clone of the message and close the original
*/
msg = AJS_CloneAndCloseMessage(widget->dukCtx, msg);
if (!msg) {
return AJ_ERR_RESOURCES;
}
if (status == AJ_OK) {
/*
* Call JavaScript to report the value change
*/
status = AJS_CPS_OnValueChanged(widget);
} else {
AJ_ErrPrintf(("SetWidgetProp %s\n", AJ_StatusText(status)));
}
if (status == AJ_OK) {
AJ_MarshalReplyMsg(msg, &reply);
} else {
AJ_MarshalStatusMsg(msg, &reply, status);
}
AJ_DeliverMsg(&reply);
return status;
}
AJ_Status AJ_PeerHandleAuthChallenge(AJ_Message* msg, AJ_Message* reply)
{
AJ_Status status;
AJ_Arg arg;
char* buf = NULL;
const AJ_GUID* peerGuid = AJ_GUID_Find(msg->sender);
/*
* We expect to know the GUID of the sender
*/
if (!peerGuid) {
return AJ_MarshalErrorMsg(msg, reply, AJ_ErrRejected);
}
/*
* Check for an authentication conversation in progress with a different peer
*/
if (authContext.peerGuid && (authContext.peerGuid != peerGuid)) {
/*
* Reject the request if the existing conversation has not expired
*/
if (AJ_GetElapsedTime(&authContext.timer, TRUE) < MAX_AUTH_TIME) {
return AJ_MarshalErrorMsg(msg, reply, AJ_ErrRejected);
}
memset(&authContext, 0, sizeof(AuthContext));
}
if (authContext.sasl.state == AJ_SASL_IDLE) {
/*
* Remember which peer is being authenticated and initialize the timeout timer
*/
authContext.peerGuid = peerGuid;
AJ_InitTimer(&authContext.timer);
/*
* Initialize SASL state machine
*/
AJ_SASL_InitContext(&authContext.sasl, authMechanisms, AJ_AUTH_CHALLENGER, msg->bus->pwdCallback);
}
if (AJ_UnmarshalArg(msg, &arg) != AJ_OK) {
goto FailAuth;
}
/*
* Need a short-lived buffer to compose the response
*/
buf = (char*)AJ_Malloc(AUTH_BUF_LEN);
if (!buf) {
status = AJ_ERR_RESOURCES;
goto FailAuth;
}
status = AJ_SASL_Advance(&authContext.sasl, (char*)arg.val.v_string, buf, AUTH_BUF_LEN);
if (status != AJ_OK) {
goto FailAuth;
}
AJ_MarshalReplyMsg(msg, reply);
AJ_MarshalArgs(reply, "s", buf);
AJ_Free(buf);
if (authContext.sasl.state == AJ_SASL_AUTHENTICATED) {
status = authContext.sasl.mechanism->Final(peerGuid);
memset(&authContext, 0, sizeof(AuthContext));
}
return status;
FailAuth:
AJ_Free(buf);
/*
* Clear current authentication context then return an error response
*/
if (authContext.sasl.mechanism) {
authContext.sasl.mechanism->Final(peerGuid);
}
memset(&authContext, 0, sizeof(AuthContext));
return AJ_MarshalErrorMsg(msg, reply, AJ_ErrSecurityViolation);
}
