/*
* Announcements are processed as follows:
*
* 1) First check if there is an existing session for the announcement sender. If not create and
* initialize an empty session object. A session object has two properties "info" which is a buffer
* that holds state information about the session and an array "anno" which is used to accumulate
* announcements from the same sender.
* 2) Unmarshal the announcement signal and if there is a callback registered for any of the
* interfaces add a service object to announcements array. The "interfaces" property on the
* service object is an array of all interfaces in the announcement.
* 3) If there is already a session with the announcement sender make callbacks now, otherwise send
* a JOIN_SESSION method call to join the session with the announcement sender. The callbacks are
* reevaluated when the JOIN_SESSION reply is received.
*/
AJ_Status AJS_AboutAnnouncement(duk_context* ctx, AJ_Message* msg)
{
AJ_BusAttachment* aj = msg->bus;
AJ_Status status;
uint16_t version;
duk_idx_t anIdx;
SessionInfo* sessionInfo;
AJ_Arg objList;
const char* sender;
AJ_InfoPrintf(("AJS_AboutAnnouncement\n"));
/*
* Ignore our own announcements
*/
if (strcmp(msg->sender, AJ_GetUniqueName(msg->bus)) == 0) {
AJ_InfoPrintf(("Ignoring our own announcement\n"));
return AJ_OK;
}
/*
* Push the sender string on the stack to stabilize it.
*/
sender = duk_push_string(ctx, msg->sender);
/*
* Announcements are accumulated in a global stash object indexed by peer name
*/
AJS_GetGlobalStashObject(ctx, "sessions");
sessionInfo = AllocSessionObject(ctx, sender);
/*
* Get the announcements array
*/
duk_get_prop_string(ctx, -1, "anno");
anIdx = duk_get_top_index(ctx);
/*
* Find out if there are JavaScript handlers for this announcement
*/
AJ_UnmarshalArgs(msg, "qq", &version, &sessionInfo->port);
status = AJ_UnmarshalContainer(msg, &objList, AJ_ARG_ARRAY);
while (status == AJ_OK) {
int ifcCount = 0;
uint8_t hasCB = FALSE;
AJ_Arg obj;
AJ_Arg interfaces;
const char* path;
status = AJ_UnmarshalContainer(msg, &obj, AJ_ARG_STRUCT);
if (status != AJ_OK) {
break;
}
AJ_UnmarshalArgs(msg, "o", &path);
/*
* Array to accumulate interfaces
*/
duk_push_array(ctx);
status = AJ_UnmarshalContainer(msg, &interfaces, AJ_ARG_ARRAY);
while (status == AJ_OK) {
/*
* Accumulate interfaces checking
*/
const char* iface;
status = AJ_UnmarshalArgs(msg, "s", &iface);
if (status == AJ_OK) {
duk_push_string(ctx, iface);
duk_put_prop_index(ctx, -2, ifcCount++);
}
/*
* We will disard the interface array if no callbacks are registered.
*/
if (!hasCB && HasServiceCallback(ctx, iface)) {
hasCB = TRUE;
}
}
if (hasCB) {
AddServiceObject(ctx, sessionInfo, path, sender);
/*
* Append service object to the announcements array for processing later
*/
duk_put_prop_index(ctx, anIdx, duk_get_length(ctx, anIdx));
} else {
/* discard the interface array */
duk_pop(ctx);
}
if (status == AJ_ERR_NO_MORE) {
status = AJ_UnmarshalCloseContainer(msg, &interfaces);
}
if (status == AJ_OK) {
status = AJ_UnmarshalCloseContainer(msg, &obj);
}
}
if (status == AJ_ERR_NO_MORE) {
status = AJ_UnmarshalCloseContainer(msg, &objList);
}
/*
* All done with this message - we need to close it now to free up the output buffer before we
* attempt to call AJ_BusJoinSession() below.
*/
AJ_CloseMsg(msg);
/* Pop "anno" and the session object */
duk_pop_2(ctx);
if (status != AJ_OK) {
goto Exit;
}
/*
* If we already have a session with this peer callback with the new service objects
*/
if (sessionInfo->sessionId) {
AnnouncementCallbacks(ctx, sender, sessionInfo);
goto Exit;
}
/*
* If there is a JOIN_SESSION in progress we have nothing more to do
*/
if (sessionInfo->replySerial != 0) {
goto Exit;
}
/*
* If announcements were registered attempt to join the session
*/
if (sessionInfo->refCount) {
status = AJ_BusJoinSession(aj, sender, sessionInfo->port, NULL);
if (status == AJ_OK) {
sessionInfo->replySerial = aj->serial - 1;
}
}
/*
* At this point if we don't have a JOIN_SESSION in progress we must delete the session object
*/
if (sessionInfo->replySerial == 0) {
duk_del_prop_string(ctx, -2, sender);
}
Exit:
/* Pop "sessions" and sender string */
duk_pop_2(ctx);
return status;
}
AJ_Status AJ_Authenticate(AJ_BusAttachment* bus)
{
AJ_Status status = AJ_OK;
AJ_Message helloResponse;
if (bus->isAuthenticated) {
// ARDP does not do SASL and it sends BusHello as part of the SYN message.
// Therefore, Hello has already been sent by the time AJ_Net_Connect() returns,
// *before* AJ_Authenticate is called.
return AJ_OK;
}
#ifdef AJ_TCP
/*
* Send initial NUL byte
*/
bus->sock.tx.writePtr[0] = 0;
bus->sock.tx.writePtr += 1;
status = bus->sock.tx.send(&bus->sock.tx);
if (status != AJ_OK) {
AJ_ErrPrintf(("AJ_Authenticate(): status=%s\n", AJ_StatusText(status)));
goto ExitConnect;
}
/* Use SASL Anonymous to connect to routing node */
status = AnonymousAuthAdvance(&bus->sock.rx, &bus->sock.tx);
if (status == AJ_OK) {
status = SendHello(bus);
}
if (status == AJ_OK) {
status = AJ_UnmarshalMsg(bus, &helloResponse, 5000);
}
if (status == AJ_OK) {
if (helloResponse.hdr->msgType == AJ_MSG_ERROR) {
AJ_ErrPrintf(("AJ_Authenticate(): AJ_ERR_TIMEOUT\n"));
status = AJ_ERR_TIMEOUT;
} else {
AJ_Arg arg;
status = AJ_UnmarshalArg(&helloResponse, &arg);
if (status == AJ_OK) {
if (arg.len >= (sizeof(bus->uniqueName) - 1)) {
AJ_ErrPrintf(("AJ_Authenticate(): AJ_ERR_ACCESS_ROUTING_NODE\n"));
status = AJ_ERR_ACCESS_ROUTING_NODE;
} else {
memcpy(bus->uniqueName, arg.val.v_string, arg.len);
bus->uniqueName[arg.len] = '\0';
}
}
}
AJ_CloseMsg(&helloResponse);
}
ExitConnect:
if (status != AJ_OK) {
AJ_InfoPrintf(("AJ_Authenticate(): status=%s\n", AJ_StatusText(status)));
} else {
bus->isAuthenticated = TRUE;
}
#endif
return status;
}
int AJ_Main(void)
{
AJ_Status status = AJ_OK;
AJ_BusAttachment bus;
uint8_t connected = FALSE;
uint32_t sessionId = 0;
AJ_Status authStatus = AJ_ERR_NULL;
/*
* One time initialization before calling any other AllJoyn APIs
*/
AJ_Initialize();
AJ_PrintXML(ProxyObjects);
AJ_RegisterObjects(NULL, ProxyObjects);
while (TRUE) {
AJ_Message msg;
if (!connected) {
status = AJ_StartClient(&bus, NULL, CONNECT_TIMEOUT, ServiceName, ServicePort, &sessionId, NULL);
if (status == AJ_OK) {
AJ_Printf("StartClient returned %d, sessionId=%u\n", status, sessionId);
AJ_Printf("Connected to Daemon:%s\n", AJ_GetUniqueName(&bus));
connected = TRUE;
if (authPeer) {
AJ_BusSetPasswordCallback(&bus, PasswordCallback);
status = AJ_BusAuthenticatePeer(&bus, ServiceName, AuthCallback, &authStatus);
if (status != AJ_OK) {
AJ_Printf("AJ_BusAuthenticatePeer returned %d\n", status);
}
} else {
authStatus = AJ_OK;
}
} else {
AJ_Printf("StartClient returned %d\n", status);
break;
}
}
if (authStatus != AJ_ERR_NULL) {
if (authStatus != AJ_OK) {
AJ_Disconnect(&bus);
break;
}
authStatus = AJ_ERR_NULL;
}
status = AJ_UnmarshalMsg(&bus, &msg, UNMARSHAL_TIMEOUT);
if (status == AJ_ERR_TIMEOUT) {
status = AppDoWork(&bus, sessionId);
continue;
}
if (status == AJ_OK) {
switch (msg.msgId) {
case PRX_MY_SIGNAL:
AJ_Printf("Received my_signal\n");
status = AJ_OK;
break;
case AJ_SIGNAL_SESSION_LOST:
/*
* Force a disconnect
*/
status = AJ_ERR_READ;
break;
default:
/*
* Pass to the built-in handlers
*/
status = AJ_BusHandleBusMessage(&msg);
break;
}
}
/*
* Messages must be closed to free resources
*/
AJ_CloseMsg(&msg);
if (status == AJ_ERR_READ) {
AJ_Printf("AllJoyn disconnect\n");
AJ_Printf("Disconnected from Daemon:%s\n", AJ_GetUniqueName(&bus));
AJ_Disconnect(&bus);
connected = FALSE;
}
}
AJ_Printf("clientlite EXIT %d\n", status);
return status;
}
int AJ_Main()
#endif
{
AJ_Status status = AJ_OK;
AJ_BusAttachment bus;
uint8_t connected = FALSE;
uint32_t sessionId = 0;
AJ_Status authStatus = AJ_ERR_NULL;
/*
* Buffer to hold the peer's full service name or unique name.
*/
#if defined (NGNS) || defined (ANNOUNCE_BASED_DISCOVERY)
char peerServiceName[AJ_MAX_NAME_SIZE + 1];
#else
char peerServiceName[AJ_MAX_SERVICE_NAME_SIZE];
#endif
#ifdef SECURE_INTERFACE
uint32_t suites[16];
size_t numsuites = 0;
uint8_t clearkeys = FALSE;
uint8_t enablepwd = FALSE;
X509CertificateChain* node;
#endif
#ifdef MAIN_ALLOWS_ARGS
#ifdef SECURE_INTERFACE
ac--;
av++;
/*
* Enable authentication mechanism by command line
*/
if (ac) {
if (0 == strncmp(*av, "-ek", 3)) {
clearkeys = TRUE;
ac--;
av++;
} else if (0 == strncmp(*av, "-e", 2)) {
ac--;
av++;
}
if (!ac) {
AJ_AlwaysPrintf(("-e(k) requires an auth mechanism.\n"));
return 1;
}
while (ac) {
if (0 == strncmp(*av, "ECDHE_ECDSA", 11)) {
suites[numsuites++] = AUTH_SUITE_ECDHE_ECDSA;
} else if (0 == strncmp(*av, "ECDHE_PSK", 9)) {
suites[numsuites++] = AUTH_SUITE_ECDHE_PSK;
} else if (0 == strncmp(*av, "ECDHE_NULL", 10)) {
suites[numsuites++] = AUTH_SUITE_ECDHE_NULL;
} else if (0 == strncmp(*av, "PIN", 3)) {
enablepwd = TRUE;
}
ac--;
av++;
}
}
#endif
#endif
/*
* One time initialization before calling any other AllJoyn APIs
*/
AJ_Initialize();
AJ_PrintXML(ProxyObjects);
AJ_RegisterObjects(NULL, ProxyObjects);
while (TRUE) {
AJ_Message msg;
if (!connected) {
#if defined (NGNS) || defined (ANNOUNCE_BASED_DISCOVERY)
status = AJ_StartClientByInterface(&bus, NULL, CONNECT_TIMEOUT, FALSE, testInterfaceNames, &sessionId, peerServiceName, NULL);
#else
status = AJ_StartClientByName(&bus, NULL, CONNECT_TIMEOUT, FALSE, testServiceName, testServicePort, &sessionId, NULL, peerServiceName);
#endif
if (status == AJ_OK) {
AJ_AlwaysPrintf(("StartClient returned %d, sessionId=%u, serviceName=%s\n", status, sessionId, peerServiceName));
AJ_AlwaysPrintf(("Connected to Daemon:%s\n", AJ_GetUniqueName(&bus)));
connected = TRUE;
#ifdef SECURE_INTERFACE
if (enablepwd) {
AJ_BusSetPasswordCallback(&bus, PasswordCallback);
}
AJ_BusEnableSecurity(&bus, suites, numsuites);
AJ_BusSetAuthListenerCallback(&bus, AuthListenerCallback);
if (clearkeys) {
status = AJ_ClearCredentials();
AJ_ASSERT(AJ_OK == status);
}
status = AJ_BusAuthenticatePeer(&bus, peerServiceName, AuthCallback, &authStatus);
if (status != AJ_OK) {
AJ_AlwaysPrintf(("AJ_BusAuthenticatePeer returned %d\n", status));
}
#else
authStatus = AJ_OK;
#endif
AJ_BusAddSignalRule(&bus, "my_signal", testInterfaceName, AJ_BUS_SIGNAL_ALLOW);
} else {
AJ_AlwaysPrintf(("StartClient returned %d\n", status));
break;
}
}
if (authStatus != AJ_ERR_NULL) {
if (authStatus != AJ_OK) {
AJ_Disconnect(&bus);
break;
}
authStatus = AJ_ERR_NULL;
}
status = AJ_UnmarshalMsg(&bus, &msg, UNMARSHAL_TIMEOUT);
if (status == AJ_ERR_TIMEOUT) {
status = AppDoWork(&bus, sessionId, peerServiceName);
continue;
}
if (status == AJ_OK) {
switch (msg.msgId) {
case PRX_MY_SIGNAL:
AJ_AlwaysPrintf(("Received my_signal\n"));
status = AJ_OK;
break;
case AJ_SIGNAL_SESSION_LOST_WITH_REASON:
/*
* Force a disconnect
*/
{
uint32_t id, reason;
AJ_UnmarshalArgs(&msg, "uu", &id, &reason);
AJ_AlwaysPrintf(("Session lost. ID = %u, reason = %u", id, reason));
}
status = AJ_ERR_SESSION_LOST;
break;
default:
/*
* Pass to the built-in handlers
*/
status = AJ_BusHandleBusMessage(&msg);
break;
}
}
/*
* Messages must be closed to free resources
*/
AJ_CloseMsg(&msg);
if ((status == AJ_ERR_SESSION_LOST) || (status == AJ_ERR_READ) || (status == AJ_ERR_LINK_DEAD)) {
AJ_AlwaysPrintf(("AllJoyn disconnect\n"));
AJ_AlwaysPrintf(("Disconnected from Daemon:%s\n", AJ_GetUniqueName(&bus)));
AJ_Disconnect(&bus);
connected = FALSE;
}
}
AJ_AlwaysPrintf(("clientlite EXIT %d\n", status));
// Clean up certificate chain
while (chain) {
node = chain;
chain = chain->next;
AJ_Free(node->certificate.der.data);
AJ_Free(node);
}
return status;
}
AJ_Status AJ_StartService(AJ_BusAttachment* bus,
const char* daemonName,
uint32_t timeout,
uint8_t connected,
uint16_t port,
const char* name,
uint32_t flags,
const AJ_SessionOpts* opts
)
{
AJ_Status status;
AJ_Time timer;
uint8_t serviceStarted = FALSE;
AJ_InfoPrintf(("AJ_StartService(bus=0x%p, daemonName=\"%s\", timeout=%d., connected=%d., port=%d., name=\"%s\", flags=0x%x, opts=0x%p)\n",
bus, daemonName, timeout, connected, port, name, flags, opts));
AJ_InitTimer(&timer);
while (TRUE) {
if (AJ_GetElapsedTime(&timer, TRUE) > timeout) {
return AJ_ERR_TIMEOUT;
}
if (!connected) {
AJ_InfoPrintf(("AJ_StartService(): AJ_FindBusAndConnect()\n"));
status = AJ_FindBusAndConnect(bus, daemonName, AJ_CONNECT_TIMEOUT);
if (status != AJ_OK) {
AJ_WarnPrintf(("AJ_StartService(): connect failed: sleeping for %d seconds\n", AJ_CONNECT_PAUSE / 1000));
AJ_Sleep(AJ_CONNECT_PAUSE);
continue;
}
AJ_InfoPrintf(("AJ_StartService(): connected to bus\n"));
}
/*
* Kick things off by binding a session port
*/
AJ_InfoPrintf(("AJ_StartService(): AJ_BindSessionPort()\n"));
status = AJ_BusBindSessionPort(bus, port, opts, 0);
if (status == AJ_OK) {
break;
}
AJ_ErrPrintf(("AJ_StartService(): AJ_Disconnect(): status=%s.\n", AJ_StatusText(status)));
AJ_Disconnect(bus);
}
while (!serviceStarted && (status == AJ_OK)) {
AJ_Message msg;
status = AJ_UnmarshalMsg(bus, &msg, AJ_UNMARSHAL_TIMEOUT);
if (status == AJ_ERR_NO_MATCH) {
// Ignore unknown messages
status = AJ_OK;
continue;
}
if (status != AJ_OK) {
AJ_ErrPrintf(("AJ_StartService(): status=%s.\n", AJ_StatusText(status)));
break;
}
switch (msg.msgId) {
case AJ_REPLY_ID(AJ_METHOD_BIND_SESSION_PORT):
if (msg.hdr->msgType == AJ_MSG_ERROR) {
AJ_ErrPrintf(("AJ_StartService(): AJ_METHOD_BIND_SESSION_PORT: %s\n", msg.error));
status = AJ_ERR_FAILURE;
} else {
AJ_InfoPrintf(("AJ_StartService(): AJ_BusRequestName()\n"));
status = AJ_BusRequestName(bus, name, flags);
}
break;
case AJ_REPLY_ID(AJ_METHOD_REQUEST_NAME):
if (msg.hdr->msgType == AJ_MSG_ERROR) {
AJ_ErrPrintf(("AJ_StartService(): AJ_METHOD_REQUEST_NAME: %s\n", msg.error));
status = AJ_ERR_FAILURE;
} else {
AJ_InfoPrintf(("AJ_StartService(): AJ_BusAdvertiseName()\n"));
status = AJ_BusAdvertiseName(bus, name, AJ_TRANSPORT_ANY, AJ_BUS_START_ADVERTISING, 0);
}
break;
case AJ_REPLY_ID(AJ_METHOD_ADVERTISE_NAME):
if (msg.hdr->msgType == AJ_MSG_ERROR) {
AJ_ErrPrintf(("AJ_StartService(): AJ_METHOD_ADVERTISE_NAME: %s\n", msg.error));
status = AJ_ERR_FAILURE;
} else {
serviceStarted = TRUE;
}
break;
default:
/*
* Pass to the built-in bus message handlers
*/
AJ_InfoPrintf(("AJ_StartService(): AJ_BusHandleBusMessage()\n"));
status = AJ_BusHandleBusMessage(&msg);
break;
}
AJ_CloseMsg(&msg);
}
if (status == AJ_OK) {
status = AJ_AboutInit(bus, port);
} else {
AJ_WarnPrintf(("AJ_StartService(): AJ_Disconnect(): status=%s\n", AJ_StatusText(status)));
AJ_Disconnect(bus);
}
return status;
}
int AJ_Main(void)
{
AJ_Status status = AJ_OK;
/* Required: Need to initialize once before starting */
AJ_Initialize();
/* Required: Register the AppObjects before starting */
AJ_RegisterObjects(NULL, AppObjects);
CPS_Init();
SetBusAuthPwdCallback(MyBusAuthPwdCB);
while (TRUE) {
/* AllJoyn related section */
AJ_Message msg;
if (!isBusConnected) {
status = CPS_StartService(&busAttachment, busAddress, CPSC_CONNECT_TIMEOUT, isBusConnected);
}
status = AJ_UnmarshalMsg(&busAttachment, &msg, CPSC_UNMARSHAL_TIMEOUT);
if (AJ_ERR_TIMEOUT == status) { // nothing on bus, do our own thing
CPS_IdleConnectedHandler(&busAttachment);
continue;
}
if (AJ_OK == status) {
if (msg.msgId == AJ_REPLY_ID(AJ_METHOD_JOIN_SESSION)) {
if (msg.hdr->msgType == AJ_MSG_ERROR) {
AJ_ErrPrintf(("Could not connect session.\n"));
} else {
uint32_t replyCode;
AJ_UnmarshalArgs(&msg, "uu", &replyCode, &sessionId);
if (replyCode == AJ_JOINSESSION_REPLY_SUCCESS) {
CPS_NotifySessionAccepted(sessionId, msg.sender);
}
}
} else {
if (CPS_MessageProcessor(&busAttachment, &msg, &status) == AJSVC_SERVICE_STATUS_NOT_HANDLED) {
//pass to build in
status = AJ_BusHandleBusMessage(&msg);
}
}
}
/* Messages MUST be discarded to free resources. */
AJ_CloseMsg(&msg);
if (status == AJ_ERR_READ) {
AJ_ErrPrintf(("AllJoyn disconnect.\n"));
AJ_Disconnect(&busAttachment);
isBusConnected = FALSE;
/* Sleep a little while before trying to reconnect. */
AJ_Sleep(CPSC_SLEEP_TIME);
}
}
AJ_InfoPrintf(("Control Panel Sample exiting with status 0x%04x.\n", status));
return status;
}
int AJ_Main(void)
{
AJ_Status status = AJ_OK;
uint8_t connected = FALSE;
uint8_t done = FALSE;
/*
* One time initialization before calling any other AllJoyn APIs
*/
AJ_Initialize();
AJ_RegisterObjects(NULL, proxyObjects);
while (!done) {
AJ_Message msg;
if (!connected) {
const char* announceRule = "type='signal',sessionless='t',interface='org.alljoyn.About',member='Announce'";
status = AJ_FindBusAndConnect(&bus, NULL, AJ_CONNECT_TIMEOUT);
if (status != AJ_OK) {
AJ_WarnPrintf(("AJ_FindBusAndConnect(): failed - sleeping for %d seconds\n", AJ_CONNECT_PAUSE / 1000));
AJ_Sleep(AJ_CONNECT_PAUSE);
continue;
}
AJ_AboutRegisterAnnounceHandlers(peerDescriptions, ArraySize(peerDescriptions));
AJ_BusSetSignalRule(&bus, announceRule, AJ_BUS_SIGNAL_ALLOW);
connected = TRUE;
}
status = AJ_UnmarshalMsg(&bus, &msg, UNMARSHAL_TIMEOUT);
if (AJ_ERR_TIMEOUT == status) {
continue;
}
if (AJ_OK == status) {
switch (msg.msgId) {
case AJ_REPLY_ID(AJ_METHOD_JOIN_SESSION):
if (msg.hdr->msgType != AJ_MSG_ERROR) {
uint32_t result;
status = AJ_UnmarshalArgs(&msg, "uu", &result, &sessionId);
if (status == AJ_OK) {
if (result == AJ_JOINSESSION_REPLY_SUCCESS) {
AJ_AlwaysPrintf(("joined session %u\n", sessionId));
DoCat();
} else {
AJ_AlwaysPrintf(("joined session rejected %d\n", result));
}
}
} else {
AJ_ErrPrintf(("JoinSession reply was error: %s\n", msg.error));
}
break;
case AJ_REPLY_ID(BASIC_CLIENT_CAT):
if (msg.hdr->msgType != AJ_MSG_ERROR) {
AJ_Arg arg;
status = AJ_UnmarshalArg(&msg, &arg);
if (AJ_OK == status) {
AJ_AlwaysPrintf(("cat returned \"%s\"\n", arg.val.v_string));
if (!waitVar) {
done = TRUE;
}
}
} else {
AJ_ErrPrintf(("Reply was error: %s\n", msg.error));
}
break;
case AJ_SIGNAL_MP_SESSION_CHANGED_WITH_REASON:
{
uint32_t sessId;
const char* peer;
uint32_t added;
uint32_t reason;
status = AJ_UnmarshalArgs(&msg, "usbu", &sessId, &peer, &added, &reason);
if (added) {
AJ_AlwaysPrintf(("Member \"%s\" added to session %u\n", peer, sessId));
} else {
AJ_AlwaysPrintf(("Member \"%s\" removed from session %u\n", peer, sessId));
}
}
break;
case AJ_SIGNAL_SESSION_LOST_WITH_REASON:
AJ_AlwaysPrintf(("Session lost\n"));
break;
default:
/* Pass to the built-in handlers. */
status = AJ_BusHandleBusMessage(&msg);
break;
}
}
/* Messages MUST be discarded to free resources. */
AJ_CloseMsg(&msg);
if (status == AJ_ERR_READ) {
AJ_AlwaysPrintf(("Connection lost\n"));
AJ_Disconnect(&bus);
exit(0);
}
}
AJ_AlwaysPrintf(("Basic client exiting with status %d.\n", status));
return status;
}
int AJ_Main(void)
{
AJ_Status status = AJ_OK;
uint8_t isUnmarshalingSuccessful = FALSE;
AJSVC_ServiceStatus serviceStatus;
AJ_Message msg;
AJ_Initialize();
AJ_AboutSetIcon(aboutIconContent, aboutIconContentSize, aboutIconMimetype, aboutIconUrl);
status = PropertyStore_Init();
if (status != AJ_OK) {
goto Exit;
}
status = Config_Init();
if (status != AJ_OK) {
goto Exit;
}
status = Onboarding_Init();
if (status != AJ_OK) {
goto Exit;
}
AJ_RegisterObjects(AppObjects, NULL);
SetBusAuthPwdCallback(MyBusAuthPwdCB);
while (TRUE) {
status = AJ_OK;
serviceStatus = AJSVC_SERVICE_STATUS_NOT_HANDLED;
if (!isBusConnected) {
isBusConnected = AJRouter_Connect(&busAttachment, ROUTER_NAME);
if (!isBusConnected) { // Failed to connect to router?
continue; // Retry establishing connection to router.
}
}
status = AJApp_ConnectedHandler(&busAttachment);
if (!AJOBS_IsWiFiConnected()) {
status = AJ_ERR_RESTART;
}
if (status == AJ_OK) {
status = AJ_UnmarshalMsg(&busAttachment, &msg, AJAPP_UNMARSHAL_TIMEOUT);
isUnmarshalingSuccessful = (status == AJ_OK);
if (status == AJ_ERR_TIMEOUT) {
if (AJ_ERR_LINK_TIMEOUT == AJ_BusLinkStateProc(&busAttachment)) {
status = AJ_ERR_READ; // something's not right. force disconnect
}
}
if (isUnmarshalingSuccessful) {
if (serviceStatus == AJSVC_SERVICE_STATUS_NOT_HANDLED) {
serviceStatus = AJApp_MessageProcessor(&busAttachment, &msg, &status);
}
if (serviceStatus == AJSVC_SERVICE_STATUS_NOT_HANDLED) {
//Pass to the built-in bus message handlers
status = AJ_BusHandleBusMessage(&msg);
}
AJ_NotifyLinkActive();
}
//Unmarshaled messages must be closed to free resources
AJ_CloseMsg(&msg);
}
if (status == AJ_ERR_READ || status == AJ_ERR_RESTART || status == AJ_ERR_RESTART_APP) {
if (isBusConnected) {
AJApp_DisconnectHandler(&busAttachment, status != AJ_ERR_READ);
isBusConnected = !AJRouter_Disconnect(&busAttachment, status != AJ_ERR_READ);
if (status == AJ_ERR_RESTART_APP) {
AJ_Reboot();
}
}
}
} // while (TRUE)
return 0;
Exit:
return (1);
}
int AJ_Main()
{
AJ_Status status;
AJ_BusAttachment bus;
int i;
AJ_Initialize();
AJ_PrintXML(AppObjects);
AJ_RegisterObjects(AppObjects, NULL);
Do_Connect(&bus);
if (authenticate) {
AJ_BusSetAuthListenerCallback(&bus, AuthListenerCallback);
} else {
authStatus = AJ_OK;
}
i = 0;
while (commands[i] != NULL) {
AJ_AlwaysPrintf(("%s\n", commands[i]));
i++;
}
i = 0;
while (TRUE) {
// check for serial input and dispatch if needed.
char buf[1024];
AJ_Message msg;
// read a line
if (commands[i] != NULL) {
char*command;
strcpy(buf, commands[i]);
AJ_AlwaysPrintf((">~~~%s\n", buf));
command = aj_strtok(buf, " \r\n");
i++;
if (0 == strcmp("startservice", command)) {
uint16_t port = 0;
const char* name;
AJ_SessionOpts opts;
char* token = aj_strtok(NULL, " \r\n");
if (token) {
name = token;
} else {
name = ServiceName;
}
token = aj_strtok(NULL, " \r\n");
if (token) {
port = (uint16_t)atoi(token);
}
if (port == 0) {
port = ServicePort;
}
token = aj_strtok(NULL, " \r\n");
if (token) {
opts.isMultipoint = (0 == strcmp("true", token));
} else {
opts.isMultipoint = 0;
}
token = aj_strtok(NULL, " \r\n");
if (token) {
opts.traffic = atoi(token);
} else {
opts.traffic = 0x1;
}
token = aj_strtok(NULL, " \r\n");
if (token) {
opts.proximity = atoi(token);
} else {
opts.proximity = 0xFF;
}
token = aj_strtok(NULL, " \r\n");
if (token) {
opts.transports = atoi(token);
} else {
opts.transports = 0xFFFF;
}
status = AJ_StartService(&bus, NULL, CONNECT_TIMEOUT, TRUE, port, name, AJ_NAME_REQ_DO_NOT_QUEUE, &opts);
AJ_BusAddSignalRule(&bus, "Chat", InterfaceName, AJ_BUS_SIGNAL_ALLOW);
} else if (0 == strcmp("find", command)) {
char* namePrefix = aj_strtok(NULL, " \r\n");
if (!namePrefix) {
AJ_AlwaysPrintf(("Usage: find <name_prefix>\n"));
continue;
}
status = AJ_BusFindAdvertisedName(&bus, namePrefix, AJ_BUS_START_FINDING);
} else if (0 == strcmp("cancelfind", command)) {
char* namePrefix = aj_strtok(NULL, " \r\n");
if (!namePrefix) {
AJ_AlwaysPrintf(("Usage: cancelfind <name_prefix>\n"));
continue;
}
status = AJ_BusFindAdvertisedName(&bus, namePrefix, AJ_BUS_STOP_FINDING);
} else if (0 == strcmp("find2", command)) {
char* namePrefix = aj_strtok(NULL, " \r\n");
uint16_t transport = 0;
char* token = aj_strtok(NULL, " \r\n");
if (token) {
transport = (uint16_t)atoi(token);
}
if (!namePrefix || !transport) {
AJ_AlwaysPrintf(("Usage: find2 <name_prefix> <transport>\n"));
continue;
}
status = AJ_BusFindAdvertisedNameByTransport(&bus, namePrefix, transport, AJ_BUS_START_FINDING);
} else if (0 == strcmp("cancelfind2", command)) {
char* namePrefix = aj_strtok(NULL, " \r\n");
uint16_t transport = 0;
char* token = aj_strtok(NULL, " \r\n");
if (token) {
transport = (uint16_t)atoi(token);
}
if (!namePrefix || !transport) {
AJ_AlwaysPrintf(("Usage: cancelfind2 <name_prefix> <transport>\n"));
continue;
}
status = AJ_BusFindAdvertisedNameByTransport(&bus, namePrefix, transport, AJ_BUS_STOP_FINDING);
} else if (0 == strcmp("requestname", command)) {
char* name = aj_strtok(NULL, " \r\n");
if (!name) {
AJ_AlwaysPrintf(("Usage: requestname <name>\n"));
continue;
}
status = AJ_BusRequestName(&bus, name, AJ_NAME_REQ_DO_NOT_QUEUE);
} else if (0 == strcmp("releasename", command)) {
char* name = aj_strtok(NULL, " \r\n");
if (!name) {
AJ_AlwaysPrintf(("Usage: releasename <name>\n"));
continue;
}
status = AJ_BusReleaseName(&bus, name);
} else if (0 == strcmp("advertise", command)) {
uint16_t transport = 0xFFFF;
char* token = NULL;
char* name = aj_strtok(NULL, " \r\n");
if (!name) {
AJ_AlwaysPrintf(("Usage: advertise <name> [transports]\n"));
continue;
}
token = aj_strtok(NULL, " \r\n");
if (token) {
transport = (uint16_t)atoi(token);
}
status = AJ_BusAdvertiseName(&bus, name, transport, AJ_BUS_START_ADVERTISING, 0);
} else if (0 == strcmp("canceladvertise", command)) {
uint16_t transport = 0xFFFF;
char* token = NULL;
char* name = aj_strtok(NULL, " \r\n");
if (!name) {
AJ_AlwaysPrintf(("Usage: canceladvertise <name> [transports]\n"));
continue;
}
token = aj_strtok(NULL, " \r\n");
if (token) {
transport = (uint16_t)atoi(token);
}
status = AJ_BusAdvertiseName(&bus, name, transport, AJ_BUS_STOP_ADVERTISING, 0);
} else if (0 == strcmp("bind", command)) {
AJ_SessionOpts opts;
uint16_t port = 0;
char* token = aj_strtok(NULL, " \r\n");
if (token) {
port = (uint16_t)atoi(token);
}
if (port == 0) {
AJ_AlwaysPrintf(("Usage: bind <port> [isMultipoint] [traffic] [proximity] [transports]\n"));
continue;
}
token = aj_strtok(NULL, " \r\n");
if (token) {
opts.isMultipoint = (0 == strcmp("true", token));
} else {
opts.isMultipoint = 0;
}
token = aj_strtok(NULL, " \r\n");
if (token) {
opts.traffic = atoi(token);
} else {
opts.traffic = 0x1;
}
token = aj_strtok(NULL, " \r\n");
if (token) {
opts.proximity = atoi(token);
} else {
opts.proximity = 0xFF;
}
token = aj_strtok(NULL, " \r\n");
if (token) {
opts.transports = atoi(token);
} else {
opts.transports = 0xFFFF;
}
status = AJ_BusBindSessionPort(&bus, port, &opts, 0);
} else if (0 == strcmp("unbind", command)) {
uint16_t port = 0;
char* token = aj_strtok(NULL, " \r\n");
if (token) {
port = (uint16_t) atoi(token);
}
if (port == 0) {
AJ_AlwaysPrintf(("Usage: unbind <port>\n"));
continue;
}
status = AJ_BusUnbindSession(&bus, port);
} else if (0 == strcmp("join", command)) {
AJ_SessionOpts opts;
uint16_t port = 0;
char* name = aj_strtok(NULL, " \r\n");
char* token = aj_strtok(NULL, " \r\n");
if (token) {
port = (uint16_t)atoi(token);
} else {
port = 0;
}
if (!name || (port == 0)) {
AJ_AlwaysPrintf(("Usage: join <name> <port> [isMultipoint] [traffic] [proximity] [transports]\n"));
continue;
}
token = aj_strtok(NULL, " \r\n");
if (token) {
opts.isMultipoint = (0 == strcmp("true", token));
} else {
opts.isMultipoint = 0;
}
token = aj_strtok(NULL, " \r\n");
if (token) {
opts.traffic = (uint8_t)atoi(token);
} else {
opts.traffic = 0x1;
}
token = aj_strtok(NULL, " \r\n");
if (token) {
opts.proximity = (uint8_t)atoi(token);
} else {
opts.proximity = 0xFF;
}
token = aj_strtok(NULL, " \r\n");
if (token) {
opts.transports = (uint16_t)atoi(token);
} else {
opts.transports = 0xFFFF;
}
status = AJ_BusJoinSession(&bus, name, port, &opts);
} else if (0 == strcmp("leave", command)) {
uint32_t sessionId = (uint32_t)atoi(aj_strtok(NULL, "\r\n"));
if (sessionId == 0) {
AJ_AlwaysPrintf(("Usage: leave <sessionId>\n"));
continue;
}
status = AJ_BusLeaveSession(&bus, sessionId);
} else if (0 == strcmp("addmatch", command)) {
char* ruleString = aj_strtok(NULL, "\r\n");
if (!ruleString) {
AJ_AlwaysPrintf(("Usage: addmatch <rule>\n"));
continue;
}
status = AJ_BusSetSignalRule(&bus, ruleString, AJ_BUS_SIGNAL_ALLOW);
} else if (0 == strcmp("removematch", command)) {
char* ruleString = aj_strtok(NULL, "\r\n");
if (!ruleString) {
AJ_AlwaysPrintf(("Usage: removematch <rule>\n"));
continue;
}
status = AJ_BusSetSignalRule(&bus, ruleString, AJ_BUS_SIGNAL_DENY);
} else if (0 == strcmp("sendttl", command)) {
int32_t ttl = 0;
char* token = aj_strtok(NULL, " \r\n");
if (token) {
ttl = atoi(token);
}
if (ttl < 0) {
AJ_AlwaysPrintf(("Usage: sendttl <ttl>\n"));
continue;
}
sendTTL = ttl;
} else if (0 == strcmp("schat", command)) {
char* chatMsg = aj_strtok(NULL, "\r\n");
if (!chatMsg) {
AJ_AlwaysPrintf(("Usage: schat <msg>\n"));
continue;
}
status = AppSendChatSignal(&bus, 0, chatMsg, AJ_FLAG_SESSIONLESS, sendTTL);
} else if (0 == strcmp("chat", command)) {
char* sessionIdString = aj_strtok(NULL, " \r\n");
char*chatMsg;
uint32_t session = g_sessionId;
if (sessionIdString != NULL) {
if (sessionIdString[0] != '#') {
session = (long)atoi(sessionIdString);
}
}
chatMsg = aj_strtok(NULL, "\r\n");
status = AppSendChatSignal(&bus, session, chatMsg, 0, sendTTL);
} else if (0 == strcmp("cancelsessionless", command)) {
uint32_t serialId = 0;
char* token = aj_strtok(NULL, " \r\n");
if (token) {
serialId = (uint32_t)atoi(token);
}
if (serialId == 0) {
AJ_AlwaysPrintf(("Invalid serial number\n"));
AJ_AlwaysPrintf(("Usage: cancelsessionless <serialNum>\n"));
continue;
}
status = AJ_BusCancelSessionless(&bus, serialId);
} else if (0 == strcmp("exit", command)) {
break;
} else if (0 == strcmp("help", command)) {
//AJ_AlwaysPrintf(("debug <module_name> <level> - Set debug level for a module\n"));
AJ_AlwaysPrintf(("startservice [name] [port] [isMultipoint] [traffic] [proximity] [transports] - Startservice\n"));
AJ_AlwaysPrintf(("requestname <name> - Request a well-known name\n"));
AJ_AlwaysPrintf(("releasename <name> - Release a well-known name\n"));
AJ_AlwaysPrintf(("bind <port> [isMultipoint] [traffic] [proximity] [transports] - Bind a session port\n"));
AJ_AlwaysPrintf(("unbind <port> - Unbind a session port\n"));
AJ_AlwaysPrintf(("advertise <name> [transports] - Advertise a name\n"));
AJ_AlwaysPrintf(("canceladvertise <name> [transports] - Cancel an advertisement\n"));
AJ_AlwaysPrintf(("find <name_prefix> - Discover names that begin with prefix\n"));
AJ_AlwaysPrintf(("find2 <name_prefix> <transport> - Discover names that begin with prefix by specific transports\n"));
AJ_AlwaysPrintf(("cancelfind <name_prefix> - Cancel discovering names that begins with prefix\n"));
AJ_AlwaysPrintf(("cancelfind2 <name_prefix> <transport> - Cancel discovering names that begins with prefix by specific transports\n"));
AJ_AlwaysPrintf(("join <name> <port> [isMultipoint] [traffic] [proximity] [transports] - Join a session\n"));
AJ_AlwaysPrintf(("leave <sessionId> - Leave a session\n"));
AJ_AlwaysPrintf(("chat <sessionId> <msg> - Send a message over a given session\n"));
AJ_AlwaysPrintf(("schat <msg> - Send a sessionless message\n"));
AJ_AlwaysPrintf(("cancelsessionless <serialNum> - Cancel a sessionless message\n"));
AJ_AlwaysPrintf(("addmatch <rule> - Add a DBUS rule\n"));
AJ_AlwaysPrintf(("removematch <rule> - Remove a DBUS rule\n"));
AJ_AlwaysPrintf(("sendttl <ttl> - Set default ttl (in ms) for all chat messages (0 = infinite)\n"));
AJ_AlwaysPrintf(("exit - Exit this program\n"));
AJ_AlwaysPrintf(("\n"));
continue;
} else if (0 == strcmp("wait", command)) {
char* token = aj_strtok(NULL, " \n\r");
if (token) {
AJ_AlwaysPrintf(("Sleeping...\n"));
AJ_Sleep((uint16_t)atoi(token));
AJ_AlwaysPrintf(("Done\n"));
}
} else {
AJ_AlwaysPrintf(("Unknown command: %s\n", command));
continue;
}
}
status = AJ_UnmarshalMsg(&bus, &msg, UNMARSHAL_TIMEOUT);
if (status != AJ_OK) {
if (status == AJ_ERR_TIMEOUT) {
AppDoWork();
continue;
}
}
if (status == AJ_OK) {
switch (msg.msgId) {
case AJ_METHOD_ACCEPT_SESSION:
{
uint16_t port;
char* joiner;
AJ_AlwaysPrintf(("Accepting...\n"));
AJ_UnmarshalArgs(&msg, "qus", &port, &g_sessionId, &joiner);
status = AJ_BusReplyAcceptSession(&msg, TRUE);
if (status == AJ_OK) {
AJ_InfoPrintf(("Accepted session session_id=%u joiner=%s\n", g_sessionId, joiner));
} else {
AJ_InfoPrintf(("AJ_BusReplyAcceptSession: error %d\n", status));
}
}
break;
case AJ_REPLY_ID(AJ_METHOD_JOIN_SESSION):
{
uint32_t replyCode;
if (msg.hdr->msgType == AJ_MSG_ERROR) {
status = AJ_ERR_FAILURE;
} else {
status = AJ_UnmarshalArgs(&msg, "uu", &replyCode, &g_sessionId);
if (replyCode == AJ_JOINSESSION_REPLY_SUCCESS) {
AJ_InfoPrintf(("Joined session session_id=%u\n", g_sessionId));
AJ_BusAddSignalRule(&bus, "Chat", InterfaceName, AJ_BUS_SIGNAL_ALLOW);
} else {
AJ_InfoPrintf(("Joined session failed\n"));
}
}
}
break;
case APP_CHAT_SIGNAL:
status = AppHandleChatSignal(&msg);
break;
case AJ_SIGNAL_SESSION_LOST_WITH_REASON:
/*
* don't force a disconnect, be ready to accept another session
*/
{
uint32_t id, reason;
AJ_UnmarshalArgs(&msg, "uu", &id, &reason);
AJ_InfoPrintf(("Session lost. ID = %u, reason = %u", id, reason));
}
break;
case AJ_SIGNAL_FOUND_ADV_NAME:
{
char* name;
char* namePrefix;
uint16_t transport;
AJ_UnmarshalArgs(&msg, "sqs", &name, &transport, &namePrefix);
AJ_AlwaysPrintf(("FoundAdvertisedName name=%s, namePrefix=%s\n", name, namePrefix));
}
break;
default:
/*
* Pass to the built-in handlers
*/
status = AJ_BusHandleBusMessage(&msg);
break;
}
}
/*
* Messages must be closed to free resources
*/
AJ_CloseMsg(&msg);
if ((status == AJ_ERR_READ) || (status == AJ_ERR_WRITE) || (status == AJ_ERR_LINK_DEAD)) {
AJ_AlwaysPrintf(("AllJoyn disconnect\n"));
AJ_AlwaysPrintf(("Disconnected from Daemon:%s\n", AJ_GetUniqueName(&bus)));
AJ_Disconnect(&bus);
connected = FALSE;
/*
* Sleep a little while before trying to reconnect
*/
AJ_Sleep(10 * 1000);
Do_Connect(&bus);
}
}
return 0;
}
AJ_Status AJS_MessageLoop(duk_context* ctx, AJ_BusAttachment* aj, duk_idx_t ajIdx)
{
AJ_Status status = AJ_OK;
AJ_Message msg;
AJ_Time timerClock;
uint32_t linkTO;
uint32_t msgTO = 0x7FFFFFFF;
duk_idx_t top = duk_get_top_index(ctx);
uint8_t ldstate;
AJ_InfoPrintf(("AJS_MessageLoop top=%d\n", (int)top));
deferredOp = AJS_OP_NONE;
if (ajIdx >= 0) {
/*
* Read the link timeout property from the config set
*/
duk_get_prop_string(ctx, -1, "config");
duk_get_prop_string(ctx, -1, "linkTimeout");
linkTO = duk_get_int(ctx, -1);
duk_pop_2(ctx);
AJ_SetBusLinkTimeout(aj, linkTO);
}
/*
* timer clock must be initialized
*/
AJ_InitTimer(&timerClock);
AJ_ASSERT(duk_get_top_index(ctx) == top);
/*
* Initialize About we can start sending announcements
*/
AJ_AboutInit(aj, AJS_APP_PORT);
while (status == AJ_OK) {
/*
* Check we are cleaning up the duktape stack correctly.
*/
if (duk_get_top_index(ctx) != top) {
AJ_ErrPrintf(("!!!AJS_MessageLoop top=%d expected %d\n", (int)duk_get_top_index(ctx), (int)top));
AJS_DumpStack(ctx);
AJ_ASSERT(duk_get_top_index(ctx) == top);
}
AJS_SetWatchdogTimer(AJS_DEFAULT_WATCHDOG_TIMEOUT);
/*
* Pinned items (strings/buffers) are only valid while running script
*/
AJS_ClearPins(ctx);
/*
* Check if there are any pending I/O operations to perform.
*/
status = AJS_ServiceIO(ctx);
if (status != AJ_OK) {
AJ_ErrPrintf(("Error servicing I/O functions\n"));
break;
}
/*
* Services the internal and timeout timers and updates the timeout value for any new
* timers that have been registered since this function was last called.
*/
status = AJS_RunTimers(ctx, &timerClock, &msgTO);
if (status != AJ_OK) {
AJ_ErrPrintf(("Error servicing timer functions\n"));
break;
}
/*
* Do any announcing required
*/
status = AJS_GetLockdownState(&ldstate);
if (status == AJ_OK && ldstate == AJS_CONSOLE_UNLOCKED) {
status = AJ_AboutAnnounce(aj);
}
if (status != AJ_OK) {
break;
}
/*
* This special wildcard allows us to unmarshal signals with any source path
*/
AJS_SetObjectPath("!");
/*
* Block until a message is received, the timeout expires, or the operation is interrupted.
*/
status = AJ_UnmarshalMsg(aj, &msg, msgTO);
if (status != AJ_OK) {
if ((status == AJ_ERR_INTERRUPTED) || (status == AJ_ERR_TIMEOUT)) {
status = AJ_OK;
continue;
}
if (status == AJ_ERR_NO_MATCH) {
status = AJ_OK;
}
AJ_CloseMsg(&msg);
continue;
}
switch (msg.msgId) {
case 0:
/* If a message was parsed but is unrecognized and should be ignored */
break;
/* Introspection messages */
case AJ_METHOD_PING:
case AJ_METHOD_BUS_PING:
case AJ_METHOD_GET_MACHINE_ID:
case AJ_METHOD_INTROSPECT:
case AJ_METHOD_GET_DESCRIPTION_LANG:
case AJ_METHOD_INTROSPECT_WITH_DESC:
/* About messages */
case AJ_METHOD_ABOUT_GET_PROP:
case AJ_METHOD_ABOUT_SET_PROP:
case AJ_METHOD_ABOUT_GET_ABOUT_DATA:
case AJ_METHOD_ABOUT_GET_OBJECT_DESCRIPTION:
case AJ_METHOD_ABOUT_ICON_GET_PROP:
case AJ_METHOD_ABOUT_ICON_SET_PROP:
case AJ_METHOD_ABOUT_ICON_GET_URL:
case AJ_METHOD_ABOUT_ICON_GET_CONTENT:
/* Authentication messages and replies */
case AJ_METHOD_EXCHANGE_GUIDS:
case AJ_REPLY_ID(AJ_METHOD_EXCHANGE_GUIDS):
case AJ_METHOD_EXCHANGE_SUITES:
case AJ_REPLY_ID(AJ_METHOD_EXCHANGE_SUITES):
case AJ_METHOD_AUTH_CHALLENGE:
case AJ_REPLY_ID(AJ_METHOD_AUTH_CHALLENGE):
case AJ_METHOD_GEN_SESSION_KEY:
case AJ_REPLY_ID(AJ_METHOD_GEN_SESSION_KEY):
case AJ_METHOD_EXCHANGE_GROUP_KEYS:
case AJ_REPLY_ID(AJ_METHOD_EXCHANGE_GROUP_KEYS):
case AJ_METHOD_KEY_EXCHANGE:
case AJ_REPLY_ID(AJ_METHOD_KEY_EXCHANGE):
case AJ_METHOD_KEY_AUTHENTICATION:
case AJ_REPLY_ID(AJ_METHOD_KEY_AUTHENTICATION):
/* Replies the app ignores */
case AJ_REPLY_ID(AJ_METHOD_ADD_MATCH):
case AJ_REPLY_ID(AJ_METHOD_REMOVE_MATCH):
case AJ_REPLY_ID(AJ_METHOD_PING):
case AJ_REPLY_ID(AJ_METHOD_BUS_PING):
/* Signals the app ignores */
case AJ_SIGNAL_PROBE_ACK:
case AJ_SIGNAL_PROBE_REQ:
case AJ_SIGNAL_NAME_OWNER_CHANGED:
status = AJ_BusHandleBusMessage(&msg);
break;
case AJ_METHOD_ACCEPT_SESSION:
status = SessionDispatcher(ctx, &msg);
break;
case AJ_REPLY_ID(AJ_METHOD_BIND_SESSION_PORT):
status = SessionBindReply(ctx, &msg);
break;
default:
status = HandleMessage(ctx, ajIdx, &msg);
break;
}
/*
* Free message resources
*/
AJ_CloseMsg(&msg);
/*
* Decide which messages should cause us to exit
*/
switch (status) {
case AJ_OK:
break;
case AJ_ERR_READ:
case AJ_ERR_WRITE:
case AJ_ERR_RESTART:
case AJ_ERR_RESTART_APP:
break;
default:
AJ_ErrPrintf(("Got error %s - continuing anyway\n", AJ_StatusText(status)));
status = AJ_OK;
}
/*
* Let link monitor know we are getting messages
*/
AJ_NotifyLinkActive();
/*
* Perform any deferred operations. These are operations such as factory reset that cannot
* be cleanly performed from inside duktape.
*/
if (status == AJ_OK) {
status = DoDeferredOperation(ctx);
}
}
AJS_ClearPins(ctx);
AJS_ClearWatchdogTimer();
return status;
}
int AJ_Main(void)
{
AJ_Status status = AJ_OK;
AJ_BusAttachment bus;
uint8_t connected = FALSE;
uint32_t sessionId = 0;
/* One time initialization before calling any other AllJoyn APIs. */
AJ_Initialize();
/* This is for debug purposes and is optional. */
AJ_PrintXML(AppObjects);
AJ_RegisterObjects(AppObjects, NULL);
while (TRUE) {
AJ_Message msg;
if (!connected) {
status = AJ_StartService(&bus,
NULL,
CONNECT_TIMEOUT,
FALSE,
ServicePort,
ServiceName,
AJ_NAME_REQ_DO_NOT_QUEUE,
NULL);
if (status != AJ_OK) {
continue;
}
AJ_InfoPrintf(("StartService returned %d, session_id=%u\n", status, sessionId));
connected = TRUE;
}
status = AJ_UnmarshalMsg(&bus, &msg, UNMARSHAL_TIMEOUT);
if (AJ_ERR_TIMEOUT == status) {
continue;
}
if (AJ_OK == status) {
switch (msg.msgId) {
case AJ_METHOD_ACCEPT_SESSION:
{
uint16_t port;
char* joiner;
AJ_UnmarshalArgs(&msg, "qus", &port, &sessionId, &joiner);
status = AJ_BusReplyAcceptSession(&msg, TRUE);
AJ_InfoPrintf(("Accepted session session_id=%u joiner=%s\n", sessionId, joiner));
}
break;
case BASIC_SERVICE_CAT:
status = AppHandleCat(&msg);
break;
case AJ_SIGNAL_SESSION_LOST_WITH_REASON:
/* Session was lost so return error to force a disconnect. */
{
uint32_t id, reason;
AJ_UnmarshalArgs(&msg, "uu", &id, &reason);
AJ_AlwaysPrintf(("Session lost. ID = %u, reason = %u", id, reason));
}
status = AJ_ERR_SESSION_LOST;
break;
default:
/* Pass to the built-in handlers. */
status = AJ_BusHandleBusMessage(&msg);
break;
}
}
/* Messages MUST be discarded to free resources. */
AJ_CloseMsg(&msg);
if (status == AJ_ERR_SESSION_LOST) {
AJ_Printf("AllJoyn disconnect.\n");
AJ_Disconnect(&bus);
connected = FALSE;
/* Sleep a little while before trying to reconnect. */
AJ_Sleep(SLEEP_TIME);
}
}
AJ_Printf("Basic service exiting with status %d.\n", status);
return status;
}
AJ_Status AJ_UnmarshalMsg(AJ_BusAttachment* bus, AJ_Message* msg, uint32_t timeout)
{
AJ_Status status;
AJ_IOBuffer* ioBuf = &bus->sock.rx;
uint8_t* endOfHeader;
uint32_t hdrPad;
/*
* Clear message then set the bus
*/
memset(msg, 0, sizeof(AJ_Message));
msg->msgId = AJ_INVALID_MSG_ID;
msg->bus = bus;
/*
* Move any unconsumed data to the start of the I/O buffer
*/
AJ_IOBufRebase(ioBuf);
/*
* Load the message header
*/
while (AJ_IO_BUF_AVAIL(ioBuf) < sizeof(AJ_MsgHeader)) {
//#pragma calls = AJ_Net_Recv
status = ioBuf->recv(ioBuf, sizeof(AJ_MsgHeader) - AJ_IO_BUF_AVAIL(ioBuf), timeout);
if (status != AJ_OK) {
/*
* If there were no messages to receive check if we have any methods call that have
* timed-out and if so generate an internal error message to allow the application to
* proceed.
*/
if ((status == AJ_ERR_TIMEOUT) && AJ_TimedOutMethodCall(msg)) {
msg->hdr = (AJ_MsgHeader*)&internalErrorHdr;
msg->error = AJ_ErrTimeout;
msg->sender = AJ_GetUniqueName(msg->bus);
msg->destination = msg->sender;
status = AJ_OK;
}
return status;
}
}
/*
* Header was unmarsalled directly into the rx buffer
*/
msg->hdr = (AJ_MsgHeader*)ioBuf->bufStart;
ioBuf->readPtr += sizeof(AJ_MsgHeader);
/*
* Quick sanity check on the header - unrecoverable error if this check fails
*/
if ((msg->hdr->endianess != AJ_LITTLE_ENDIAN) && (msg->hdr->endianess != AJ_BIG_ENDIAN)) {
return AJ_ERR_READ;
}
/*
* Endian swap header info - conventiently they are contiguous in the header
*/
EndianSwap(msg, AJ_ARG_INT32, &msg->hdr->bodyLen, 3);
msg->bodyBytes = msg->hdr->bodyLen;
/*
* The header is null padded to an 8 bytes boundary
*/
hdrPad = (8 - msg->hdr->headerLen) & 7;
/*
* Load the header
*/
status = LoadBytes(ioBuf, msg->hdr->headerLen + hdrPad, 0);
if (status != AJ_OK) {
return status;
}
#ifndef NDEBUG
/*
* Check that messages are getting closed
*/
AJ_ASSERT(!currentMsg);
currentMsg = msg;
#endif
/*
* Assume an empty signature
*/
msg->signature = "";
/*
* We have the header in the buffer now we can unmarshal the header fields
*/
endOfHeader = ioBuf->bufStart + sizeof(AJ_MsgHeader) + msg->hdr->headerLen;
while (ioBuf->readPtr < endOfHeader) {
const char* fieldSig;
uint8_t fieldId;
AJ_Arg hdrVal;
/*
* Custom unmarshal the header field - signature is "(yv)" so starts off with STRUCT aligment.
*/
status = LoadBytes(ioBuf, 4, PadForType(AJ_ARG_STRUCT, ioBuf));
if (status != AJ_OK) {
break;
}
fieldId = ioBuf->readPtr[0];
fieldSig = (const char*)&ioBuf->readPtr[2];
ioBuf->readPtr += 4;
/*
* Now unmarshal the field value
*/
status = Unmarshal(msg, &fieldSig, &hdrVal);
if (status != AJ_OK) {
break;
}
/*
* Check the field has the type we expect - we ignore fields we don't know
*/
if ((fieldId <= AJ_HDR_SESSION_ID) && (TypeForHdr[fieldId] != hdrVal.typeId)) {
status = AJ_ERR_UNMARSHAL;
break;
}
/*
* Set the field value in the message
*/
switch (fieldId) {
case AJ_HDR_OBJ_PATH:
msg->objPath = hdrVal.val.v_objPath;
break;
case AJ_HDR_INTERFACE:
msg->iface = hdrVal.val.v_string;
break;
case AJ_HDR_MEMBER:
msg->member = hdrVal.val.v_string;
break;
case AJ_HDR_ERROR_NAME:
msg->error = hdrVal.val.v_string;
break;
case AJ_HDR_REPLY_SERIAL:
msg->replySerial = *(hdrVal.val.v_uint32);
break;
case AJ_HDR_DESTINATION:
msg->destination = hdrVal.val.v_string;
break;
case AJ_HDR_SENDER:
msg->sender = hdrVal.val.v_string;
break;
case AJ_HDR_SIGNATURE:
msg->signature = hdrVal.val.v_signature;
break;
case AJ_HDR_TIMESTAMP:
msg->timestamp = *(hdrVal.val.v_uint32);
break;
case AJ_HDR_TIME_TO_LIVE:
msg->ttl = *(hdrVal.val.v_uint32);
break;
case AJ_HDR_SESSION_ID:
msg->sessionId = *(hdrVal.val.v_uint32);
break;
case AJ_HDR_HANDLES:
case AJ_HDR_COMPRESSION_TOKEN:
default:
/* Ignored */
break;
}
}
if (status == AJ_OK) {
AJ_ASSERT(ioBuf->readPtr == endOfHeader);
/*
* Consume the header pad bytes.
*/
ioBuf->readPtr += hdrPad;
/*
* If the message is encrypted load the entire message body and decrypt it.
*/
if (msg->hdr->flags & AJ_FLAG_ENCRYPTED) {
status = LoadBytes(ioBuf, msg->hdr->bodyLen, 0);
if (status == AJ_OK) {
status = DecryptMessage(msg);
}
}
/*
* Toggle the AUTO_START flag so in the API no flags == 0
*
* Note we must do this after decrypting the message or message authentication will fail.
*/
msg->hdr->flags ^= AJ_FLAG_AUTO_START;
/*
* If the message looks good try to identify it.
*/
if (status == AJ_OK) {
status = AJ_IdentifyMessage(msg);
}
} else {
/*
* Consume entire header
*/
ioBuf->readPtr = endOfHeader + hdrPad;
}
if (status == AJ_OK) {
AJ_DumpMsg("RECEIVED", msg, FALSE);
} else {
/*
* Silently discard message unless in debug mode
*/
AJ_ErrPrintf(("Discarding bad message %s\n", AJ_StatusText(status)));
AJ_DumpMsg("DISCARDING", msg, FALSE);
AJ_CloseMsg(msg);
}
return status;
}
int AJ_Main(void)
{
AJ_Status status = AJ_OK;
AJ_BusAttachment bus;
uint8_t connected = FALSE;
uint32_t sessionId = 0;
/*
* One time initialization before calling any other AllJoyn APIs
*/
AJ_Initialize();
AJ_PrintXML(AppObjects);
AJ_RegisterObjects(AppObjects, NULL);
while (TRUE) {
AJ_Message msg;
if (!connected) {
status = AJ_StartService(&bus, DaemonServiceName, CONNECT_TIMEOUT, FALSE, ServicePort, ServiceName, AJ_NAME_REQ_DO_NOT_QUEUE, NULL);
if (status != AJ_OK) {
continue;
}
AJ_InfoPrintf(("StartService returned AJ_OK; running %s:%u\n", ServiceName, ServicePort));
connected = TRUE;
AJ_BusSetPasswordCallback(&bus, PasswordCallback);
}
status = AJ_UnmarshalMsg(&bus, &msg, UNMARSHAL_TIMEOUT);
if (status != AJ_OK) {
if (status == AJ_ERR_TIMEOUT) {
AppDoWork();
continue;
}
}
if (status == AJ_OK) {
switch (msg.msgId) {
case AJ_METHOD_ACCEPT_SESSION:
{
AJ_InfoPrintf(("Accepting...\n"));
uint16_t port;
char* joiner;
AJ_UnmarshalArgs(&msg, "qus", &port, &sessionId, &joiner);
status = AJ_BusReplyAcceptSession(&msg, TRUE);
if (status == AJ_OK) {
AJ_InfoPrintf(("Accepted session session_id=%u joiner=%s\n", sessionId, joiner));
} else {
AJ_InfoPrintf(("AJ_BusReplyAcceptSession: error %d\n", status));
}
}
break;
case APP_FLASH:
status = AppHandleFlash(&msg);
break;
case APP_ON:
AppHandleOnOff(&msg, TRUE);
break;
case APP_OFF:
AppHandleOnOff(&msg, FALSE);
break;
case AJ_SIGNAL_SESSION_LOST_WITH_REASON:
/*
* Force a disconnect
*/
status = AJ_ERR_READ;
break;
default:
/*
* Pass to the built-in bus message handlers
*/
status = AJ_BusHandleBusMessage(&msg);
break;
}
}
/*
* Unarshaled messages must be closed to free resources
*/
AJ_CloseMsg(&msg);
if (status == AJ_ERR_READ) {
AJ_AlwaysPrintf(("AllJoyn disconnect\n"));
AJ_Disconnect(&bus);
connected = FALSE;
/*
* Sleep a little while before trying to reconnect
*/
AJ_Sleep(10 * 1000);
}
}
AJ_AlwaysPrintf(("svclite EXIT %d\n", status));
return status;
}
int AJ_Main(void)
{
AJ_Status status = AJ_OK;
AJ_BusAttachment bus;
uint8_t connected = FALSE;
uint32_t sessionId = 0;
/*
* One time initialization before calling any other AllJoyn APIs
*/
AJ_Initialize();
AJ_PrintXML(AppObjects);
AJ_RegisterObjects(AppObjects, NULL);
SetBusAuthPwdCallback(MyBusAuthPwdCB);
while (TRUE) {
AJ_Message msg;
if (!connected) {
status = AJ_StartService(&bus, NULL, CONNECT_TIMEOUT, FALSE, ServicePort, ServiceName, AJ_NAME_REQ_DO_NOT_QUEUE, NULL);
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, PasswordCallback);
/* Configure timeout for the link to the daemon bus */
AJ_SetBusLinkTimeout(&bus, 60); // 60 seconds
}
status = AJ_UnmarshalMsg(&bus, &msg, UNMARSHAL_TIMEOUT);
if (AJ_ERR_TIMEOUT == status && AJ_ERR_LINK_TIMEOUT == AJ_BusLinkStateProc(&bus)) {
status = AJ_ERR_READ;
}
if (status != AJ_OK) {
if (status == AJ_ERR_TIMEOUT) {
AppDoWork();
continue;
}
}
if (status == AJ_OK) {
switch (msg.msgId) {
case AJ_REPLY_ID(AJ_METHOD_ADD_MATCH):
if (msg.hdr->msgType == AJ_MSG_ERROR) {
AJ_InfoPrintf(("Failed to add match\n"));
status = AJ_ERR_FAILURE;
} else {
status = AJ_OK;
}
break;
case AJ_METHOD_ACCEPT_SESSION:
{
uint16_t port;
char* joiner;
AJ_UnmarshalArgs(&msg, "qus", &port, &sessionId, &joiner);
if (port == ServicePort) {
status = AJ_BusReplyAcceptSession(&msg, TRUE);
AJ_InfoPrintf(("Accepted session session_id=%u joiner=%s\n", sessionId, joiner));
} else {
status = AJ_BusReplyAcceptSession(&msg, FALSE);
AJ_InfoPrintf(("Accepted rejected session_id=%u joiner=%s\n", sessionId, joiner));
}
}
break;
case APP_MY_PING:
status = AppHandlePing(&msg);
break;
case APP_GET_PROP:
status = AJ_BusPropGet(&msg, PropGetHandler, NULL);
break;
case APP_SET_PROP:
status = AJ_BusPropSet(&msg, PropSetHandler, NULL);
if (status == AJ_OK) {
AJ_InfoPrintf(("Property successfully set to %d.\n", propVal));
} else {
AJ_InfoPrintf(("Property set attempt unsuccessful. Status = 0x%04x.\n", status));
}
break;
case AJ_SIGNAL_SESSION_LOST_WITH_REASON:
{
uint32_t id, reason;
AJ_UnmarshalArgs(&msg, "uu", &id, &reason);
AJ_InfoPrintf(("Session lost. ID = %u, reason = %u", id, reason));
if (CancelAdvertiseName) {
status = AJ_BusAdvertiseName(&bus, ServiceName, AJ_TRANSPORT_ANY, AJ_BUS_START_ADVERTISING, 0);
}
status = AJ_ERR_SESSION_LOST;
}
break;
case AJ_SIGNAL_SESSION_JOINED:
if (CancelAdvertiseName) {
status = AJ_BusAdvertiseName(&bus, ServiceName, AJ_TRANSPORT_ANY, AJ_BUS_STOP_ADVERTISING, 0);
}
break;
case AJ_REPLY_ID(AJ_METHOD_CANCEL_ADVERTISE):
case AJ_REPLY_ID(AJ_METHOD_ADVERTISE_NAME):
if (msg.hdr->msgType == AJ_MSG_ERROR) {
status = AJ_ERR_FAILURE;
}
break;
case APP_MY_SIGNAL:
AJ_InfoPrintf(("Received my_signal\n"));
status = AJ_OK;
if (ReflectSignal) {
AJ_Message out;
AJ_MarshalSignal(&bus, &out, APP_MY_SIGNAL, msg.destination, msg.sessionId, 0, 0);
AJ_MarshalArgs(&out, "a{ys}", 0, NULL);
AJ_DeliverMsg(&out);
AJ_CloseMsg(&out);
}
break;
default:
/*
* Pass to the built-in bus message handlers
*/
status = AJ_BusHandleBusMessage(&msg);
break;
}
// 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) || (status == AJ_ERR_LINK_DEAD)) {
AJ_InfoPrintf(("AllJoyn disconnect\n"));
AJ_InfoPrintf(("Disconnected from Daemon:%s\n", AJ_GetUniqueName(&bus)));
AJ_Disconnect(&bus);
connected = FALSE;
/*
* Sleep a little while before trying to reconnect
*/
AJ_Sleep(10 * 1000);
}
}
AJ_WarnPrintf(("svclite EXIT %d\n", status));
return status;
}
AJ_Status AJ_Connect(AJ_BusAttachment* bus, const char* serviceName, uint32_t timeout)
{
AJ_Status status;
AJ_SASL_Context sasl;
AJ_Service service;
/*
* Clear the bus struct
*/
memset(bus, 0, sizeof(AJ_BusAttachment));
/*
* Clear stale name->GUID mappings
*/
AJ_GUID_ClearNameMap();
/*
* Host-specific network bring-up procedure. This includes establishing a connection to the
* network and initializing the I/O buffers.
*/
status = AJ_Net_Up();
if (status != AJ_OK) {
return status;
}
/*
* Discover a daemon or service to connect to
*/
if (!serviceName) {
serviceName = daemonService;
}
#if AJ_CONNECT_LOCALHOST
service.ipv4port = 9955;
#if HOST_IS_LITTLE_ENDIAN
service.ipv4 = 0x0100007F; // 127.0.0.1
#endif
#if HOST_IS_BIG_ENDIAN
service.ipv4 = 0x7f000001; // 127.0.0.1
#endif
service.addrTypes = AJ_ADDR_IPV4;
#elif defined ARDUINO
service.ipv4port = 9955;
service.ipv4 = 0x6501A8C0; // 192.168.1.101
service.addrTypes = AJ_ADDR_IPV4;
status = AJ_Discover(serviceName, &service, timeout);
if (status != AJ_OK) {
goto ExitConnect;
}
#elif defined AJ_SERIAL_CONNECTION
// don't bother with discovery, we are connected to a daemon.
#else
status = AJ_Discover(serviceName, &service, timeout);
if (status != AJ_OK) {
goto ExitConnect;
}
#endif
status = AJ_Net_Connect(&bus->sock, service.ipv4port, service.addrTypes & AJ_ADDR_IPV4, &service.ipv4);
if (status != AJ_OK) {
goto ExitConnect;
}
/*
* Send initial NUL byte
*/
bus->sock.tx.writePtr[0] = 0;
bus->sock.tx.writePtr += 1;
status = bus->sock.tx.send(&bus->sock.tx);
if (status != AJ_OK) {
goto ExitConnect;
}
AJ_SASL_InitContext(&sasl, mechList, AJ_AUTH_RESPONDER, busAuthPwdFunc);
while (TRUE) {
status = AuthAdvance(&sasl, &bus->sock.rx, &bus->sock.tx);
if ((status != AJ_OK) || (sasl.state == AJ_SASL_FAILED)) {
break;
}
if (sasl.state == AJ_SASL_AUTHENTICATED) {
status = SendHello(bus);
break;
}
}
if (status == AJ_OK) {
AJ_Message helloResponse;
status = AJ_UnmarshalMsg(bus, &helloResponse, 5000);
if (status == AJ_OK) {
/*
* The only error we might get is a timeout
*/
if (helloResponse.hdr->msgType == AJ_MSG_ERROR) {
status = AJ_ERR_TIMEOUT;
} else {
AJ_Arg arg;
status = AJ_UnmarshalArg(&helloResponse, &arg);
if (status == AJ_OK) {
if (arg.len >= (sizeof(bus->uniqueName) - 1)) {
status = AJ_ERR_RESOURCES;
} else {
memcpy(bus->uniqueName, arg.val.v_string, arg.len);
bus->uniqueName[arg.len] = '\0';
}
}
}
AJ_CloseMsg(&helloResponse);
}
}
ExitConnect:
if (status != AJ_OK) {
AJ_Printf("AllJoyn connect failed %d\n", status);
AJ_Disconnect(bus);
}
return status;
}
AJ_Status AJ_StartClient(AJ_BusAttachment* bus,
const char* daemonName,
uint32_t timeout,
uint8_t connected,
const char* name,
uint16_t port,
uint32_t* sessionId,
const AJ_SessionOpts* opts)
{
AJ_Status status = AJ_OK;
AJ_Time timer;
uint8_t foundName = FALSE;
uint8_t clientStarted = FALSE;
uint32_t elapsed = 0;
AJ_InfoPrintf(("AJ_StartClient(bus=0x%p, daemonName=\"%s\", timeout=%d., connected=%d., name=\"%s\", port=%d., sessionId=0x%p, opts=0x%p)\n",
bus, daemonName, timeout, connected, name, port, sessionId, opts));
AJ_InitTimer(&timer);
while (elapsed < timeout) {
if (!connected) {
AJ_InfoPrintf(("AJ_StartClient(): AJ_FindBusAndConnect()\n"));
status = AJ_FindBusAndConnect(bus, daemonName, AJ_CONNECT_TIMEOUT);
elapsed = AJ_GetElapsedTime(&timer, TRUE);
if (status != AJ_OK) {
elapsed += AJ_CONNECT_PAUSE;
if (elapsed > timeout) {
break;
}
AJ_WarnPrintf(("Failed to connect to bus sleeping for %d seconds\n", AJ_CONNECT_PAUSE / 1000));
AJ_Sleep(AJ_CONNECT_PAUSE);
continue;
}
AJ_InfoPrintf(("AllJoyn client connected to bus\n"));
}
/*
* Kick things off by finding the service names
*/
AJ_InfoPrintf(("AJ_StartClient(): AJ_BusFindAdvertisedName()\n"));
status = AJ_BusFindAdvertisedName(bus, name, AJ_BUS_START_FINDING);
if (status == AJ_OK) {
break;
}
if (!connected) {
AJ_WarnPrintf(("AjStartClient2(): AJ_Disconnect(): status=%s.\n", AJ_StatusText(status)));
AJ_Disconnect(bus);
}
}
if (elapsed > timeout) {
return AJ_ERR_TIMEOUT;
}
timeout -= elapsed;
*sessionId = 0;
while (!clientStarted && (status == AJ_OK)) {
AJ_Message msg;
status = AJ_UnmarshalMsg(bus, &msg, AJ_UNMARSHAL_TIMEOUT);
if ((status == AJ_ERR_TIMEOUT) && !foundName) {
/*
* Timeouts are expected until we find a name
*/
if (timeout < AJ_UNMARSHAL_TIMEOUT) {
return status;
}
timeout -= AJ_UNMARSHAL_TIMEOUT;
status = AJ_OK;
continue;
}
if (status != AJ_OK) {
AJ_ErrPrintf(("AJ_StartClient(): status=%s\n", AJ_StatusText(status)));
break;
}
switch (msg.msgId) {
case AJ_REPLY_ID(AJ_METHOD_FIND_NAME):
case AJ_REPLY_ID(AJ_METHOD_FIND_NAME_BY_TRANSPORT):
if (msg.hdr->msgType == AJ_MSG_ERROR) {
AJ_ErrPrintf(("AJ_StartClient(): AJ_METHOD_FIND_NAME: %s\n", msg.error));
status = AJ_ERR_FAILURE;
} else {
uint32_t disposition;
AJ_UnmarshalArgs(&msg, "u", &disposition);
if ((disposition != AJ_FIND_NAME_STARTED) && (disposition != AJ_FIND_NAME_ALREADY)) {
AJ_ErrPrintf(("AJ_StartClient(): AJ_ERR_FAILURE\n"));
status = AJ_ERR_FAILURE;
}
}
break;
case AJ_SIGNAL_FOUND_ADV_NAME:
{
AJ_Arg arg;
AJ_UnmarshalArg(&msg, &arg);
AJ_InfoPrintf(("FoundAdvertisedName(%s)\n", arg.val.v_string));
foundName = TRUE;
status = AJ_BusJoinSession(bus, arg.val.v_string, port, opts);
}
break;
case AJ_REPLY_ID(AJ_METHOD_JOIN_SESSION):
{
uint32_t replyCode;
if (msg.hdr->msgType == AJ_MSG_ERROR) {
AJ_ErrPrintf(("AJ_StartClient(): AJ_METHOD_JOIN_SESSION: %s\n", msg.error));
status = AJ_ERR_FAILURE;
} else {
status = AJ_UnmarshalArgs(&msg, "uu", &replyCode, sessionId);
if (replyCode == AJ_JOINSESSION_REPLY_SUCCESS) {
clientStarted = TRUE;
} else {
AJ_ErrPrintf(("AJ_StartClient(): AJ_ERR_FAILURE\n"));
status = AJ_ERR_FAILURE;
}
}
}
break;
case AJ_SIGNAL_SESSION_LOST_WITH_REASON:
/*
* Force a disconnect
*/
{
uint32_t id, reason;
AJ_UnmarshalArgs(&msg, "uu", &id, &reason);
AJ_InfoPrintf(("Session lost. ID = %u, reason = %u", id, reason));
}
AJ_ErrPrintf(("AJ_StartClient(): AJ_SIGNAL_SESSION_LOST_WITH_REASON: AJ_ERR_READ\n"));
status = AJ_ERR_READ;
break;
default:
/*
* Pass to the built-in bus message handlers
*/
AJ_InfoPrintf(("AJ_StartClient(): AJ_BusHandleBusMessage()\n"));
status = AJ_BusHandleBusMessage(&msg);
break;
}
AJ_CloseMsg(&msg);
}
if (status != AJ_OK) {
AJ_WarnPrintf(("AJ_StartClient(): AJ_Disconnect(): status=%s\n", AJ_StatusText(status)));
AJ_Disconnect(bus);
}
return status;
}
AJ_Status AJS_AttachAllJoyn(AJ_BusAttachment* aj)
{
AJ_Status status;
uint8_t isConnected = FALSE;
uint32_t linkTO = LINK_TO;
size_t sapSz;
/*
* Initialize the onboarding service
*/
sapSz = min(sizeof(obSettings.AJOBS_SoftAPSSID), sizeof(softAPSSID));
memcpy((char*)obSettings.AJOBS_SoftAPSSID, softAPSSID, sapSz);
status = AJOBS_Start(&obSettings);
if (status != AJ_OK) {
goto Exit;
}
AJ_InfoPrintf(("Attempting to attach to AllJoyn\n"));
while (!isConnected) {
status = AJSVC_RoutingNodeConnect(aj, busNode, CONNECT_TO, CONNECT_PAUSE, linkTO, &isConnected);
if (status != AJ_ERR_TIMEOUT) {
break;
}
}
if (isConnected) {
status = AJS_ServicesInit(aj);
if (status != AJ_OK) {
AJ_ErrPrintf(("Failed to initialize services"));
}
}
if (isConnected && (AJOBS_GetState() != AJOBS_STATE_CONFIGURED_VALIDATED)) {
/*
* Kick of onboarding
*/
status = AJ_BusBindSessionPort(aj, ONBOARDING_PORT, NULL, 0);
/*
* Allow onboarding service to run its course
*/
while (status == AJ_OK) {
AJ_Message msg;
status = AJ_UnmarshalMsg(aj, &msg, MSG_TO);
if (status == AJ_ERR_NO_MATCH) {
/*
* Discard unknown messages
*/
status = AJ_CloseMsg(&msg);
continue;
}
if (status == AJ_ERR_TIMEOUT) {
/*
* Check the link is still up
*/
status = AJ_BusLinkStateProc(aj);
if (status == AJ_OK) {
continue;
}
}
if (status != AJ_OK) {
break;
}
switch (msg.msgId) {
case AJ_REPLY_ID(AJ_METHOD_BIND_SESSION_PORT):
AJ_AboutInit(aj, ONBOARDING_PORT);
break;
case AJ_METHOD_ACCEPT_SESSION:
/*
* TODO - check that the port number is correct
*/
status = AJ_BusReplyAcceptSession(&msg, TRUE);
if (status == AJ_OK) {
status = AJOBS_ConnectedHandler(aj);
}
break;
default:
/*
* Let the service message handlers have first dibs on the message
*/
status = AJS_ServicesMsgHandler(&msg);
if (status == AJ_ERR_NO_MATCH) {
/*
* Pass the unhandled message to the standard bus handler
*/
status = AJ_BusHandleBusMessage(&msg);
if (status == AJ_ERR_NO_MATCH) {
AJ_ErrPrintf(("Discarding unhandled message\n"));
status = AJ_OK;
}
}
break;
}
/*
* Let the link monitor know we are receiving messages
*/
AJ_NotifyLinkActive();
/*
* Free resources used by the message
*/
AJ_CloseMsg(&msg);
if (AJOBS_GetState() == AJOBS_STATE_CONFIGURED_VALIDATED) {
AJ_InfoPrintf(("Onboarding completed\n"));
break;
}
AJ_InfoPrintf(("Onboarding continuing\n"));
}
/*
* If we got an error during onboarding we should restart
*/
if (status != AJ_OK) {
status = AJ_ERR_RESTART;
}
}
/*
* If all went well let the services know we are connected
*/
if (isConnected && (status == AJ_OK)) {
/*
* Add match rules to subscribe to session related signals
*/
status = AJ_BusSetSignalRuleFlags(aj, sessionLostMatchRule, AJ_BUS_SIGNAL_ALLOW, AJ_FLAG_NO_REPLY_EXPECTED);
if (status == AJ_OK) {
status = AJSVC_ConnectedHandler(aj);
}
}
Exit:
return status;
}
int AJ_Main()
{
AJ_Status status = AJ_OK;
AJ_BusAttachment bus;
uint8_t connected = FALSE;
uint32_t sessionId = 0;
X509CertificateChain* node;
/*
* One time initialization before calling any other AllJoyn APIs
*/
AJ_Initialize();
AJ_PrintXML(AppObjects);
AJ_RegisterObjects(AppObjects, NULL);
AJ_AboutRegisterPropStoreGetter(AboutPropGetter);
SetBusAuthPwdCallback(MyBusAuthPwdCB);
while (TRUE) {
AJ_Message msg;
if (!connected) {
status = AJ_StartService(&bus, NULL, CONNECT_TIMEOUT, FALSE, ServicePort, ServiceName, AJ_NAME_REQ_DO_NOT_QUEUE, NULL);
if (status != AJ_OK) {
continue;
}
AJ_InfoPrintf(("StartService returned AJ_OK\n"));
AJ_InfoPrintf(("Connected to Daemon:%s\n", AJ_GetUniqueName(&bus)));
AJ_SetIdleTimeouts(&bus, 10, 4);
connected = TRUE;
#ifdef SECURE_OBJECT
status = AJ_SetObjectFlags("/org/alljoyn/alljoyn_test", AJ_OBJ_FLAG_SECURE, 0);
if (status != AJ_OK) {
AJ_ErrPrintf(("Error calling AJ_SetObjectFlags.. [%s] \n", AJ_StatusText(status)));
return -1;
}
#endif
#if defined(SECURE_INTERFACE) || defined(SECURE_OBJECT)
/* Register a callback for providing bus authentication password */
AJ_BusSetPasswordCallback(&bus, PasswordCallback);
AJ_BusEnableSecurity(&bus, suites, numsuites);
AJ_BusSetAuthListenerCallback(&bus, AuthListenerCallback);
#endif
/* Configure timeout for the link to the daemon bus */
AJ_SetBusLinkTimeout(&bus, 60); // 60 seconds
}
status = AJ_UnmarshalMsg(&bus, &msg, UNMARSHAL_TIMEOUT);
if (AJ_ERR_TIMEOUT == status && AJ_ERR_LINK_TIMEOUT == AJ_BusLinkStateProc(&bus)) {
status = AJ_ERR_READ;
}
if (status != AJ_OK) {
if (status == AJ_ERR_TIMEOUT) {
AppDoWork();
continue;
}
}
if (status == AJ_OK) {
switch (msg.msgId) {
case AJ_REPLY_ID(AJ_METHOD_ADD_MATCH):
if (msg.hdr->msgType == AJ_MSG_ERROR) {
AJ_InfoPrintf(("Failed to add match\n"));
status = AJ_ERR_FAILURE;
} else {
status = AJ_OK;
}
break;
case AJ_METHOD_ACCEPT_SESSION:
{
uint16_t port;
char* joiner;
AJ_UnmarshalArgs(&msg, "qus", &port, &sessionId, &joiner);
if (port == ServicePort) {
status = AJ_BusReplyAcceptSession(&msg, TRUE);
AJ_InfoPrintf(("Accepted session session_id=%u joiner=%s\n", sessionId, joiner));
} else {
status = AJ_BusReplyAcceptSession(&msg, FALSE);
AJ_InfoPrintf(("Accepted rejected session_id=%u joiner=%s\n", sessionId, joiner));
}
}
break;
case APP_MY_PING:
status = AppHandlePing(&msg);
break;
case APP_GET_PROP:
status = AJ_BusPropGet(&msg, PropGetHandler, NULL);
break;
case APP_SET_PROP:
status = AJ_BusPropSet(&msg, PropSetHandler, NULL);
if (status == AJ_OK) {
AJ_InfoPrintf(("Property successfully set to %d.\n", propVal));
} else {
AJ_InfoPrintf(("Property set attempt unsuccessful. Status = 0x%04x.\n", status));
}
break;
case AJ_SIGNAL_SESSION_LOST_WITH_REASON:
{
uint32_t id, reason;
AJ_UnmarshalArgs(&msg, "uu", &id, &reason);
AJ_InfoPrintf(("Session lost. ID = %u, reason = %u", id, reason));
if (CancelAdvertiseName) {
status = AJ_BusAdvertiseName(&bus, ServiceName, AJ_TRANSPORT_ANY, AJ_BUS_START_ADVERTISING, 0);
}
status = AJ_ERR_SESSION_LOST;
}
break;
case AJ_SIGNAL_SESSION_JOINED:
if (CancelAdvertiseName) {
status = AJ_BusAdvertiseName(&bus, ServiceName, AJ_TRANSPORT_ANY, AJ_BUS_STOP_ADVERTISING, 0);
}
break;
case AJ_REPLY_ID(AJ_METHOD_CANCEL_ADVERTISE):
case AJ_REPLY_ID(AJ_METHOD_ADVERTISE_NAME):
if (msg.hdr->msgType == AJ_MSG_ERROR) {
status = AJ_ERR_FAILURE;
}
break;
case AJ_REPLY_ID(AJ_METHOD_BUS_SET_IDLE_TIMEOUTS):
{
uint32_t disposition, idleTo, probeTo;
if (msg.hdr->msgType == AJ_MSG_ERROR) {
status = AJ_ERR_FAILURE;
}
AJ_UnmarshalArgs(&msg, "uuu", &disposition, &idleTo, &probeTo);
AJ_InfoPrintf(("SetIdleTimeouts response disposition=%u idleTimeout=%u probeTimeout=%u\n", disposition, idleTo, probeTo));
}
break;
case APP_MY_SIGNAL:
AJ_InfoPrintf(("Received my_signal\n"));
status = AJ_OK;
if (ReflectSignal) {
AJ_Message out;
AJ_Arg arg;
AJ_MarshalSignal(&bus, &out, APP_MY_SIGNAL, msg.sender, msg.sessionId, 0, 0);
AJ_MarshalContainer(&out, &arg, AJ_ARG_ARRAY);
AJ_MarshalCloseContainer(&out, &arg);
AJ_DeliverMsg(&out);
AJ_CloseMsg(&out);
}
break;
default:
/*
* Pass to the built-in bus message handlers
*/
status = AJ_BusHandleBusMessage(&msg);
break;
}
// 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) || (status == AJ_ERR_LINK_DEAD)) {
AJ_InfoPrintf(("AllJoyn disconnect\n"));
AJ_InfoPrintf(("Disconnected from Daemon:%s\n", AJ_GetUniqueName(&bus)));
AJ_Disconnect(&bus);
connected = FALSE;
/*
* Sleep a little while before trying to reconnect
*/
AJ_Sleep(10 * 1000);
}
}
AJ_WarnPrintf(("svclite EXIT %d\n", status));
#if defined(SECURE_INTERFACE) || defined(SECURE_OBJECT)
// Clean up certificate chain
while (chain) {
node = chain;
chain = chain->next;
AJ_Free(node->certificate.der.data);
AJ_Free(node);
}
#endif
return status;
}
AJ_Status AJNS_Consumer_NotifySignalHandler(AJ_Message* msg)
{
AJ_Status status;
AJNS_Notification notification;
AJNS_NotificationContent content;
char appId[UUID_LENGTH * 2 + 1];
AJ_Arg attrbtArray;
AJ_Arg customAttributeArray;
AJ_Arg notTextArray;
AJ_Arg richAudioArray;
memset(¬ification, 0, sizeof(AJNS_Notification));
memset(&content, 0, sizeof(AJNS_NotificationContent));
notification.content = &content;
AJ_InfoPrintf(("Received notification signal from sender %s\n", msg->sender));
status = AJ_UnmarshalArgs(msg, "q", ¬ification.version);
if (status != AJ_OK) {
goto Exit;
}
status = AJ_UnmarshalArgs(msg, "i", ¬ification.notificationId);
if (status != AJ_OK) {
goto Exit;
}
status = AJ_UnmarshalArgs(msg, "q", ¬ification.messageType);
if (status != AJ_OK) {
goto Exit;
}
status = AJ_UnmarshalArgs(msg, "s", ¬ification.deviceId);
if (status != AJ_OK) {
goto Exit;
}
status = AJ_UnmarshalArgs(msg, "s", ¬ification.deviceName);
if (status != AJ_OK) {
goto Exit;
}
status = AJSVC_UnmarshalAppId(msg, appId, sizeof(appId));
if (status != AJ_OK) {
goto Exit;
}
notification.appId = appId;
status = AJ_UnmarshalArgs(msg, "s", ¬ification.appName);
if (status != AJ_OK) {
goto Exit;
}
status = AJ_UnmarshalContainer(msg, &attrbtArray, AJ_ARG_ARRAY);
if (status != AJ_OK) {
goto Exit;
}
while (1) {
AJ_Arg dictArg;
int32_t attrbtKey;
const char* variantSig;
status = AJ_UnmarshalContainer(msg, &dictArg, AJ_ARG_DICT_ENTRY);
if (status == AJ_ERR_NO_MORE) {
status = AJ_UnmarshalCloseContainer(msg, &attrbtArray);
if (status != AJ_OK) {
goto Exit;
} else {
break;
}
} else if (status == AJ_OK) {
goto Exit;
}
status = AJ_UnmarshalArgs(msg, "i", &attrbtKey);
if (status != AJ_OK) {
goto Exit;
}
switch (attrbtKey) {
case AJNS_RICH_CONTENT_ICON_URL_ATTRIBUTE_KEY:
{
status = AJ_UnmarshalVariant(msg, &variantSig);
if (status != AJ_OK) {
goto Exit;
}
status = AJ_UnmarshalArgs(msg, "s", &(notification.content->richIconUrl));
if (status != AJ_OK) {
goto Exit;
}
}
break;
case AJNS_RICH_CONTENT_ICON_OBJECT_PATH_ATTRIBUTE_KEY:
{
status = AJ_UnmarshalVariant(msg, &variantSig);
if (status != AJ_OK) {
goto Exit;
}
status = AJ_UnmarshalArgs(msg, "s", &(notification.content->richIconObjectPath));
if (status != AJ_OK) {
goto Exit;
}
}
break;
case AJNS_RICH_CONTENT_AUDIO_OBJECT_PATH_ATTRIBUTE_KEY:
{
status = AJ_UnmarshalVariant(msg, &variantSig);
if (status != AJ_OK) {
goto Exit;
}
status = AJ_UnmarshalArgs(msg, "s", &(notification.content->richAudioObjectPath));
if (status != AJ_OK) {
goto Exit;
}
}
break;
case AJNS_CONTROLPANELSERVICE_OBJECT_PATH_ATTRIBUTE_KEY:
{
status = AJ_UnmarshalVariant(msg, &variantSig);
if (status != AJ_OK) {
goto Exit;
}
status = AJ_UnmarshalArgs(msg, "s", &(notification.content->controlPanelServiceObjectPath));
if (status != AJ_OK) {
goto Exit;
}
}
break;
case AJNS_ORIGINAL_SENDER_NAME_ATTRIBUTE_KEY:
{
status = AJ_UnmarshalVariant(msg, &variantSig);
if (status != AJ_OK) {
goto Exit;
}
status = AJ_UnmarshalArgs(msg, "s", ¬ification.originalSenderName);
if (status != AJ_OK) {
goto Exit;
}
}
break;
case AJNS_RICH_CONTENT_AUDIO_URL_ATTRIBUTE_KEY:
{
status = AJ_UnmarshalVariant(msg, &variantSig);
if (status != AJ_OK) {
goto Exit;
}
status = AJ_UnmarshalContainer(msg, &richAudioArray, AJ_ARG_ARRAY);
if (status != AJ_OK) {
goto Exit;
}
while (1) {
AJ_Arg structArg;
char* urlLanguage;
char* urlText;
status = AJ_UnmarshalContainer(msg, &structArg, AJ_ARG_STRUCT);
if (status == AJ_ERR_NO_MORE) {
status = AJ_UnmarshalCloseContainer(msg, &richAudioArray);
if (status != AJ_OK) {
goto Exit;
} else {
break;
}
} else if (status == AJ_OK) {
goto Exit;
}
status = AJ_UnmarshalArgs(msg, "ss", &urlLanguage, &urlText);
if (status != AJ_OK) {
goto Exit;
}
if (notification.content->numAudioUrls < NUMALLOWEDRICHNOTS) { // if it doesn't fit we just skip
richAudiosRecd[notification.content->numAudioUrls].key = urlLanguage;
richAudiosRecd[notification.content->numAudioUrls].value = urlText;
notification.content->numAudioUrls++;
}
status = AJ_UnmarshalCloseContainer(msg, &structArg);
if (status != AJ_OK) {
goto Exit;
}
}
notification.content->richAudioUrls = richAudiosRecd;
}
break;
default:
AJ_InfoPrintf(("Unknown argument - skipping\n"));
status = AJ_SkipArg(msg);
if (status != AJ_OK) {
AJ_ErrPrintf(("Error could not skip argument\n"));
return status;
}
}
status = AJ_UnmarshalCloseContainer(msg, &dictArg);
if (status != AJ_OK) {
goto Exit;
}
}
status = AJ_UnmarshalContainer(msg, &customAttributeArray, AJ_ARG_ARRAY);
if (status != AJ_OK) {
goto Exit;
}
while (1) {
AJ_Arg customAttributeDictArg;
char* customKey;
char* customVal;
status = AJ_UnmarshalContainer(msg, &customAttributeDictArg, AJ_ARG_DICT_ENTRY);
if (status == AJ_ERR_NO_MORE) {
status = AJ_UnmarshalCloseContainer(msg, &customAttributeArray);
if (status != AJ_OK) {
goto Exit;
} else {
break;
}
} else if (status == AJ_OK) {
goto Exit;
}
status = AJ_UnmarshalArgs(msg, "ss", &customKey, &customVal);
if (status != AJ_OK) {
goto Exit;
}
if (notification.content->numCustomAttributes < NUMALLOWEDCUSTOMATTRIBUTES) { // if it doesn't fit we just skip
customAttributesRecd[notification.content->numCustomAttributes].key = customKey;
customAttributesRecd[notification.content->numCustomAttributes].value = customVal;
notification.content->numCustomAttributes++;
}
status = AJ_UnmarshalCloseContainer(msg, &customAttributeDictArg);
if (status != AJ_OK) {
goto Exit;
}
}
notification.content->customAttributes = customAttributesRecd;
status = AJ_UnmarshalContainer(msg, ¬TextArray, AJ_ARG_ARRAY);
if (status != AJ_OK) {
goto Exit;
}
while (1) {
AJ_Arg structArg;
char* notificationLanguage;
char* notificationText;
status = AJ_UnmarshalContainer(msg, &structArg, AJ_ARG_STRUCT);
if (status == AJ_ERR_NO_MORE) {
status = AJ_UnmarshalCloseContainer(msg, ¬TextArray);
if (status != AJ_OK) {
goto Exit;
} else {
break;
}
} else if (status == AJ_OK) {
goto Exit;
}
status = AJ_UnmarshalArgs(msg, "ss", ¬ificationLanguage, ¬ificationText);
if (status != AJ_OK) {
goto Exit;
}
if (notification.content->numTexts < NUMALLOWEDTEXTS) { // if it doesn't fit we just skip
textsRecd[notification.content->numTexts].key = notificationLanguage;
textsRecd[notification.content->numTexts].value = notificationText;
notification.content->numTexts++;
}
status = AJ_UnmarshalCloseContainer(msg, &structArg);
if (status != AJ_OK) {
goto Exit;
}
}
notification.content->texts = textsRecd;
Exit:
if (status != AJ_OK) {
AJ_ErrPrintf(("Handle Notification failed: '%s'\n", AJ_StatusText(status)));
} else {
if (appOnNotify) {
status = (*appOnNotify)(¬ification);
}
}
AJ_CloseMsg(msg);
return status;
}
AJ_Status AJ_Authenticate(AJ_BusAttachment* bus)
{
AJ_Status status = AJ_OK;
AJ_SASL_Context sasl;
/*
* Send initial NUL byte
*/
bus->sock.tx.writePtr[0] = 0;
bus->sock.tx.writePtr += 1;
status = bus->sock.tx.send(&bus->sock.tx);
if (status != AJ_OK) {
AJ_InfoPrintf(("AJ_Authenticate(): status=%s\n", AJ_StatusText(status)));
goto ExitConnect;
}
AJ_SASL_InitContext(&sasl, mechList, AJ_AUTH_RESPONDER, busAuthPwdFunc, FALSE);
while (TRUE) {
status = AuthAdvance(&sasl, &bus->sock.rx, &bus->sock.tx);
if ((status != AJ_OK) || (sasl.state == AJ_SASL_FAILED)) {
break;
}
if (sasl.state == AJ_SASL_AUTHENTICATED) {
status = SendHello(bus);
break;
}
}
if (status == AJ_OK) {
AJ_Message helloResponse;
status = AJ_UnmarshalMsg(bus, &helloResponse, 5000);
if (status == AJ_OK) {
/*
* The only error we might get is a timeout
*/
if (helloResponse.hdr->msgType == AJ_MSG_ERROR) {
status = AJ_ERR_TIMEOUT;
} else {
AJ_Arg arg;
status = AJ_UnmarshalArg(&helloResponse, &arg);
if (status == AJ_OK) {
if (arg.len >= (sizeof(bus->uniqueName) - 1)) {
AJ_ErrPrintf(("AJ_Authenticate(): AJ_ERR_RESOURCES\n"));
status = AJ_ERR_RESOURCES;
} else {
memcpy(bus->uniqueName, arg.val.v_string, arg.len);
bus->uniqueName[arg.len] = '\0';
}
}
}
AJ_CloseMsg(&helloResponse);
// subscribe to the signal NameOwnerChanged and wait for the response
status = AJ_BusSetSignalRule(bus, "type='signal',member='NameOwnerChanged',interface='org.freedesktop.DBus'", AJ_BUS_SIGNAL_ALLOW);
if (status == AJ_OK) {
uint8_t found_reply = FALSE;
AJ_Message msg;
AJ_Time timer;
AJ_InitTimer(&timer);
while (found_reply == FALSE && AJ_GetElapsedTime(&timer, TRUE) < 3000) {
status = AJ_UnmarshalMsg(bus, &msg, 3000);
if (status == AJ_OK) {
switch (msg.msgId) {
case AJ_REPLY_ID(AJ_METHOD_ADD_MATCH):
found_reply = TRUE;
break;
default:
// ignore everything else
AJ_BusHandleBusMessage(&msg);
break;
}
AJ_CloseMsg(&msg);
}
}
}
}
}
ExitConnect:
if (status != AJ_OK) {
AJ_InfoPrintf(("AJ_Authenticate(): status=%s\n", AJ_StatusText(status)));
}
return status;
}
int AJ_Main(void)
{
static AJ_Status status = AJ_OK;
static uint8_t isUnmarshalingSuccessful = FALSE;
AJSVC_ServiceStatus serviceStatus;
AJ_Initialize();
status = PropertyStore_Init();
if (status != AJ_OK) {
goto Exit;
}
status = About_Init(AnnounceObjects, aboutIconMimetype, aboutIconContent, aboutIconContentSize, aboutIconUrl);
if (status != AJ_OK) {
goto Exit;
}
status = AJServices_Init(AppObjects, ProxyObjects, AnnounceObjects, deviceManufactureName, deviceProductName);
if (status != AJ_OK) {
goto Exit;
}
AJ_RegisterObjects(AppObjects, ProxyObjects);
SetBusAuthPwdCallback(MyBusAuthPwdCB);
while (TRUE) {
AJ_Message msg;
status = AJ_OK;
if (!isBusConnected) {
isBusConnected = AJRouter_Connect(&busAttachment, ROUTER_NAME);
if (isBusConnected) {
status = AJServices_ConnectedHandler(&busAttachment);
} else { // Failed to connect to daemon.
continue; // Retry establishing connection to daemon.
}
}
if (status == AJ_OK) {
status = AJApp_ConnectedHandler(&busAttachment);
}
if (status == AJ_OK) {
status = AJ_UnmarshalMsg(&busAttachment, &msg, AJAPP_UNMARSHAL_TIMEOUT);
isUnmarshalingSuccessful = (status == AJ_OK);
if (status == AJ_ERR_TIMEOUT) {
if (AJ_ERR_LINK_TIMEOUT == AJ_BusLinkStateProc(&busAttachment)) {
status = AJ_ERR_READ; // something's not right. force disconnect
} else { // nothing on bus, do our own thing
AJ_Printf("do our own things\n");
AJServices_DoWork(&busAttachment);
continue;
}
}
if (isUnmarshalingSuccessful) {
serviceStatus = AJServices_MessageProcessor(&busAttachment, &msg, &status);
if (serviceStatus == AJSVC_SERVICE_STATUS_NOT_HANDLED) {
//Pass to the built-in bus message handlers
status = AJ_BusHandleBusMessage(&msg);
}
AJ_NotifyLinkActive();
}
//Unmarshaled messages must be closed to free resources
AJ_CloseMsg(&msg);
}
if (status == AJ_ERR_READ || status == AJ_ERR_RESTART || status == AJ_ERR_RESTART_APP) {
if (isBusConnected) {
AJApp_DisconnectHandler(&busAttachment, status != AJ_ERR_READ);
AJServices_DisconnectHandler();
isBusConnected = !AJRouter_Disconnect(&busAttachment, status != AJ_ERR_READ);
if (status == AJ_ERR_RESTART_APP) {
AJ_Reboot();
}
}
}
} // while (TRUE)
return 0;
Exit:
return (1);
}
int AJ_Main(int argc, char** argv)
{
AJ_Status status = AJ_OK;
AJ_BusAttachment bus;
uint8_t connected = FALSE;
uint32_t sessionId = 0;
uint16_t state;
uint16_t capabilities;
uint16_t info;
/* One time initialization before calling any other AllJoyn APIs. */
AJ_Initialize();
/* This is for debug purposes and is optional. */
AJ_PrintXML(AppObjects);
AJ_RegisterObjects(AppObjects, NULL);
while (TRUE) {
AJ_Message msg;
if (!connected) {
status = AJ_StartService(&bus,
NULL,
CONNECT_TIMEOUT,
FALSE,
ServicePort,
ServiceName,
AJ_NAME_REQ_DO_NOT_QUEUE,
NULL);
if (status != AJ_OK) {
continue;
}
AJ_InfoPrintf(("StartService returned %d, session_id=%u\n", status, sessionId));
connected = TRUE;
AJ_BusEnableSecurity(&bus, suites, numsuites);
AJ_BusSetAuthListenerCallback(&bus, AuthListenerCallback);
AJ_ManifestTemplateSet(&manifest);
AJ_SecurityGetClaimConfig(&state, &capabilities, &info);
/* Set app claimable if not already claimed */
if (APP_STATE_CLAIMED != state) {
AJ_SecuritySetClaimConfig(&bus, APP_STATE_CLAIMABLE, CLAIM_CAPABILITY_ECDHE_PSK, 0);
}
}
status = AJ_UnmarshalMsg(&bus, &msg, UNMARSHAL_TIMEOUT);
if (AJ_ERR_TIMEOUT == status) {
continue;
}
if (AJ_OK == status) {
switch (msg.msgId) {
case AJ_METHOD_ACCEPT_SESSION:
{
uint16_t port;
char* joiner;
AJ_UnmarshalArgs(&msg, "qus", &port, &sessionId, &joiner);
if (port == ServicePort) {
status = AJ_BusReplyAcceptSession(&msg, TRUE);
AJ_InfoPrintf(("Accepted session session_id=%u joiner=%s\n", sessionId, joiner));
} else {
status = AJ_ResetArgs(&msg);
if (AJ_OK != status) {
break;
}
status = AJ_BusHandleBusMessage(&msg);
}
}
break;
case BASIC_SERVICE_PING:
status = AppHandlePing(&msg);
break;
case AJ_SIGNAL_SESSION_LOST_WITH_REASON:
/* Force a disconnect. */
{
uint32_t id, reason;
AJ_UnmarshalArgs(&msg, "uu", &id, &reason);
AJ_AlwaysPrintf(("Session lost. ID = %u, reason = %u", id, reason));
}
status = AJ_ERR_SESSION_LOST;
break;
default:
/* Pass to the built-in handlers. */
status = AJ_BusHandleBusMessage(&msg);
break;
}
}
/* Messages MUST be discarded to free resources. */
AJ_CloseMsg(&msg);
if ((status == AJ_ERR_READ) || (status == AJ_ERR_WRITE)) {
AJ_Printf("AllJoyn disconnect.\n");
AJ_Disconnect(&bus);
connected = FALSE;
/* Sleep a little while before trying to reconnect. */
AJ_Sleep(SLEEP_TIME);
}
}
AJ_Printf("Secure service exiting with status 0x%04x.\n", status);
// Clean up certificate chain
while (chain) {
node = chain;
chain = chain->next;
AJ_Free(node->certificate.der.data);
AJ_Free(node);
}
return status;
}
AJ_Status AJ_RunAllJoynService(AJ_BusAttachment* bus, AllJoynConfiguration* config)
{
uint8_t connected = FALSE;
AJ_Status status = AJ_OK;
AJ_InfoPrintf(("AJ_RunAllJoynService(bus=0x%p, config=0x%p)\n", bus, config));
while (TRUE) {
AJ_Time start = { 0, 0 };
AJ_Message msg;
uint32_t now;
// get the next timeout
uint32_t next;
// wait forever
uint32_t timeout = (uint32_t) -1;
if (!connected) {
status = AJ_StartService(
bus,
config->daemonName, config->connect_timeout, config->connected,
config->session_port, config->service_name, config->flags, config->opts);
if (status != AJ_OK) {
AJ_ErrPrintf(("AJ_RunAllJoynService(): status=%s.\n", AJ_StatusText(status)));
continue;
}
AJ_InfoPrintf(("AJ_RunAllJoynService(): 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)) {
AJ_ErrPrintf(("AJ_RunAllJoynService(): AJ_ERR_READ\n"));
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 {
AJ_InfoPrintf(("AJ_RunAllJoynService(): AJ_BusHandleBusMessage()\n"));
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) || (status == AJ_ERR_LINK_DEAD)) {
AJ_InfoPrintf(("AJ_RunAllJoynService(): AJ_Disconnect(): 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_InfoPrintf(("AJ_RunAllJoynService(): AJ_Sleep()\n"));
AJ_Sleep(10 * 1000);
}
}
// this will never actually return!
return AJ_OK;
}
int main(int argc, char*argv[])
{
AJ_Status status = AJ_ERR_INVALID;
if (argc > 1) {
AJ_BusAttachment bus;
uint8_t connected = FALSE;
uint8_t done = FALSE;
uint32_t sessionId = 0;
char*newName = argv[1];
status = AJ_OK;
/*
* One time initialization before calling any other AllJoyn APIs
*/
AJ_Initialize();
AJ_PrintXML(AppObjects);
AJ_RegisterObjects(NULL, AppObjects);
while (!done) {
AJ_Message msg;
if (!connected) {
status = AJ_StartClient(&bus,
NULL,
CONNECT_TIMEOUT,
FALSE,
ServiceName,
ServicePort,
&sessionId,
NULL);
if (status == AJ_OK) {
AJ_InfoPrintf(("StartClient returned %d, sessionId=%u.\n", status, sessionId));
connected = TRUE;
SendNewName(&bus, sessionId, newName);
} else {
AJ_InfoPrintf(("StartClient returned 0x%04x.\n", status));
break;
}
}
status = AJ_UnmarshalMsg(&bus, &msg, UNMARSHAL_TIMEOUT);
if (AJ_ERR_TIMEOUT == status) {
continue;
}
if (AJ_OK == status) {
switch (msg.msgId) {
case AJ_REPLY_ID(PRX_SET_PROP):
done = TRUE;
AJ_Printf("Name on the interface '%s' at service '%s' was set to '%s'.\n",
InterfaceName,
ServiceName,
newName);
break;
case AJ_SIGNAL_SESSION_LOST_WITH_REASON:
/* Force a disconnect. */
{
uint32_t id, reason;
AJ_UnmarshalArgs(&msg, "uu", &id, &reason);
AJ_AlwaysPrintf(("Session lost. ID = %u, reason = %u", id, reason));
}
status = AJ_ERR_SESSION_LOST;
break;
default:
/* Pass to the built-in handlers. */
status = AJ_BusHandleBusMessage(&msg);
break;
}
}
/* Messages MUST be discarded to free resources. */
AJ_CloseMsg(&msg);
if (status == AJ_ERR_SESSION_LOST) {
AJ_Printf("AllJoyn disconnect.\n");
AJ_Disconnect(&bus);
exit(0);
}
}
} else {
AJ_ErrPrintf(("Error. New name not given: nameChange_client [new name].\n"));
}
AJ_Printf("nameChange_Client exiting with status 0x%04x.\n", status);
return status;
}
static
AJ_Status StartClient(AJ_BusAttachment* bus,
const char* daemonName,
uint32_t timeout,
uint8_t connected,
const char* name,
uint16_t port,
const char** interfaces,
uint32_t* sessionId,
char* serviceName,
const AJ_SessionOpts* opts)
{
AJ_Status status = AJ_OK;
AJ_Time timer;
uint8_t found = FALSE;
uint8_t clientStarted = FALSE;
uint32_t elapsed = 0;
char* rule;
size_t ruleLen;
const char* base = "interface='org.alljoyn.About',sessionless='t'";
const char* impl = ",implements='";
const char** ifaces;
AJ_InfoPrintf(("AJ_StartClient(bus=0x%p, daemonName=\"%s\", timeout=%d., connected=%d., interface=\"%p\", sessionId=0x%p, serviceName=0x%p, opts=0x%p)\n",
bus, daemonName, timeout, connected, interfaces, sessionId, serviceName, opts));
AJ_InitTimer(&timer);
if ((name == NULL && interfaces == NULL) ||
(name != NULL && interfaces != NULL)) {
return AJ_ERR_INVALID;
}
while (elapsed < timeout) {
if (!connected) {
status = AJ_FindBusAndConnect(bus, daemonName, AJ_CONNECT_TIMEOUT);
elapsed = AJ_GetElapsedTime(&timer, TRUE);
if (status != AJ_OK) {
elapsed += AJ_CONNECT_PAUSE;
if (elapsed > timeout) {
break;
}
AJ_WarnPrintf(("AJ_StartClient(): Failed to connect to bus, sleeping for %d seconds\n", AJ_CONNECT_PAUSE / 1000));
AJ_Sleep(AJ_CONNECT_PAUSE);
continue;
}
AJ_InfoPrintf(("AJ_StartClient(): AllJoyn client connected to bus\n"));
}
if (name != NULL) {
/*
* Kick things off by finding the service names
*/
status = AJ_BusFindAdvertisedName(bus, name, AJ_BUS_START_FINDING);
AJ_InfoPrintf(("AJ_StartClient(): AJ_BusFindAdvertisedName()\n"));
} else {
/*
* Kick things off by finding all services that implement the interface
*/
ruleLen = strlen(base) + 1;
ifaces = interfaces;
while (*ifaces != NULL) {
ruleLen += strlen(impl) + strlen(*ifaces) + 1;
ifaces++;
}
rule = (char*) AJ_Malloc(ruleLen);
if (rule == NULL) {
status = AJ_ERR_RESOURCES;
break;
}
strcpy(rule, base);
ifaces = interfaces;
while (*ifaces != NULL) {
strcat(rule, impl);
if ((*ifaces)[0] == '$') {
strcat(rule, &(*ifaces)[1]);
} else {
strcat(rule, *ifaces);
}
strcat(rule, "'");
ifaces++;
}
status = AJ_BusSetSignalRule(bus, rule, AJ_BUS_SIGNAL_ALLOW);
AJ_InfoPrintf(("AJ_StartClient(): Client SetSignalRule: %s\n", rule));
AJ_Free(rule);
}
if (status == AJ_OK) {
break;
}
if (!connected) {
AJ_WarnPrintf(("AJ_StartClient(): Client disconnecting from bus: status=%s.\n", AJ_StatusText(status)));
AJ_Disconnect(bus);
}
}
if (elapsed > timeout) {
AJ_WarnPrintf(("AJ_StartClient(): Client timed-out trying to connect to bus: status=%s.\n", AJ_StatusText(status)));
return AJ_ERR_TIMEOUT;
}
timeout -= elapsed;
if (status != AJ_OK) {
return status;
}
*sessionId = 0;
if (serviceName != NULL) {
*serviceName = '\0';
}
while (!clientStarted && (status == AJ_OK)) {
AJ_Message msg;
status = AJ_UnmarshalMsg(bus, &msg, AJ_UNMARSHAL_TIMEOUT);
if ((status == AJ_ERR_TIMEOUT) && !found) {
/*
* Timeouts are expected until we find a name or service
*/
if (timeout < AJ_UNMARSHAL_TIMEOUT) {
return status;
}
timeout -= AJ_UNMARSHAL_TIMEOUT;
status = AJ_OK;
continue;
}
if (status == AJ_ERR_NO_MATCH) {
// Ignore unknown messages
status = AJ_OK;
continue;
}
if (status != AJ_OK) {
AJ_ErrPrintf(("AJ_StartClient(): status=%s\n", AJ_StatusText(status)));
break;
}
switch (msg.msgId) {
case AJ_REPLY_ID(AJ_METHOD_FIND_NAME):
case AJ_REPLY_ID(AJ_METHOD_FIND_NAME_BY_TRANSPORT):
if (msg.hdr->msgType == AJ_MSG_ERROR) {
AJ_ErrPrintf(("AJ_StartClient(): AJ_METHOD_FIND_NAME: %s\n", msg.error));
status = AJ_ERR_FAILURE;
} else {
uint32_t disposition;
AJ_UnmarshalArgs(&msg, "u", &disposition);
if ((disposition != AJ_FIND_NAME_STARTED) && (disposition != AJ_FIND_NAME_ALREADY)) {
AJ_ErrPrintf(("AJ_StartClient(): AJ_ERR_FAILURE\n"));
status = AJ_ERR_FAILURE;
}
}
break;
case AJ_SIGNAL_FOUND_ADV_NAME:
{
AJ_Arg arg;
AJ_UnmarshalArg(&msg, &arg);
AJ_InfoPrintf(("FoundAdvertisedName(%s)\n", arg.val.v_string));
found = TRUE;
status = AJ_BusJoinSession(bus, arg.val.v_string, port, opts);
}
break;
case AJ_SIGNAL_ABOUT_ANNOUNCE:
{
uint16_t version, port;
AJ_InfoPrintf(("AJ_StartClient(): AboutAnnounce from (%s)\n", msg.sender));
if (!found) {
found = TRUE;
AJ_UnmarshalArgs(&msg, "qq", &version, &port);
status = AJ_BusJoinSession(bus, msg.sender, port, opts);
if (serviceName != NULL) {
strncpy(serviceName, msg.sender, AJ_MAX_NAME_SIZE);
serviceName[AJ_MAX_NAME_SIZE] = '\0';
}
if (status != AJ_OK) {
AJ_ErrPrintf(("AJ_StartClient(): BusJoinSession failed (%s)\n", AJ_StatusText(status)));
}
}
}
break;
case AJ_REPLY_ID(AJ_METHOD_JOIN_SESSION):
{
uint32_t replyCode;
if (msg.hdr->msgType == AJ_MSG_ERROR) {
AJ_ErrPrintf(("AJ_StartClient(): AJ_METHOD_JOIN_SESSION: %s\n", msg.error));
status = AJ_ERR_FAILURE;
} else {
status = AJ_UnmarshalArgs(&msg, "uu", &replyCode, sessionId);
if (replyCode == AJ_JOINSESSION_REPLY_SUCCESS) {
clientStarted = TRUE;
} else {
AJ_ErrPrintf(("AJ_StartClient(): AJ_METHOD_JOIN_SESSION reply (%d)\n", replyCode));
status = AJ_ERR_FAILURE;
}
}
}
break;
case AJ_SIGNAL_SESSION_LOST_WITH_REASON:
/*
* Force a disconnect
*/
{
uint32_t id, reason;
AJ_UnmarshalArgs(&msg, "uu", &id, &reason);
AJ_InfoPrintf(("Session lost. ID = %u, reason = %u", id, reason));
}
AJ_ErrPrintf(("AJ_StartClient(): AJ_SIGNAL_SESSION_LOST_WITH_REASON: AJ_ERR_READ\n"));
status = AJ_ERR_READ;
break;
default:
/*
* Pass to the built-in bus message handlers
*/
AJ_InfoPrintf(("AJ_StartClient(): AJ_BusHandleBusMessage()\n"));
status = AJ_BusHandleBusMessage(&msg);
break;
}
AJ_CloseMsg(&msg);
}
if (status != AJ_OK && !connected) {
AJ_WarnPrintf(("AJ_StartClient(): Client disconnecting from bus: status=%s\n", AJ_StatusText(status)));
AJ_Disconnect(bus);
}
return status;
}
int AJ_Main()
{
AJ_Status status;
AJ_BusAttachment bus;
AJ_Message txMsg;
AJ_Message rxMsg;
AJ_Arg arg;
AJ_Arg array1;
AJ_Arg array2;
AJ_Arg struct1;
AJ_Arg struct2;
size_t sz;
uint32_t i;
uint32_t j;
uint32_t k;
uint32_t key;
uint32_t len;
uint32_t u;
uint32_t v;
int32_t n;
int32_t m;
uint16_t q;
uint16_t r;
uint8_t y;
char* str;
char* sig;
void* raw;
bus.sock.tx.direction = AJ_IO_BUF_TX;
bus.sock.tx.bufSize = sizeof(txBuffer);
bus.sock.tx.bufStart = txBuffer;
bus.sock.tx.readPtr = bus.sock.tx.bufStart;
bus.sock.tx.writePtr = bus.sock.tx.bufStart;
bus.sock.tx.send = TxFunc;
bus.sock.rx.direction = AJ_IO_BUF_RX;
bus.sock.rx.bufSize = sizeof(rxBuffer);
bus.sock.rx.bufStart = rxBuffer;
bus.sock.rx.readPtr = bus.sock.rx.bufStart;
bus.sock.rx.writePtr = bus.sock.rx.bufStart;
bus.sock.rx.recv = RxFunc;
/*
* Set the hook
*/
#ifndef NDEBUG
MutterHook = MsgInit;
#else
AJ_Printf("mutter only works in DEBUG builds\n");
return -1;
#endif
for (i = 0; i < ArraySize(testSignature); ++i) {
status = AJ_MarshalSignal(&bus, &txMsg, i, "mutter.service", 0, 0, 0);
if (status != AJ_OK) {
break;
}
switch (i) {
case 0:
CHECK(AJ_MarshalContainer(&txMsg, &array1, AJ_ARG_ARRAY));
for (key = 0; key < ArraySize(Fruits); ++key) {
AJ_Arg dict;
CHECK(AJ_MarshalContainer(&txMsg, &dict, AJ_ARG_DICT_ENTRY));
CHECK(AJ_MarshalArgs(&txMsg, "us", key, Fruits[key]));
CHECK(AJ_MarshalCloseContainer(&txMsg, &dict));
}
if (status == AJ_OK) {
CHECK(AJ_MarshalCloseContainer(&txMsg, &array1));
}
break;
case 1:
CHECK(AJ_MarshalArgs(&txMsg, "u", 11111));
CHECK(AJ_MarshalContainer(&txMsg, &struct1, AJ_ARG_STRUCT));
CHECK(AJ_MarshalArgs(&txMsg, "usu", 22222, "hello", 33333));
CHECK(AJ_MarshalContainer(&txMsg, &struct2, AJ_ARG_STRUCT));
CHECK(AJ_MarshalArgs(&txMsg, "ii", -100, -200));
CHECK(AJ_MarshalCloseContainer(&txMsg, &struct2));
CHECK(AJ_MarshalArgs(&txMsg, "qsq", 4444, "goodbye", 5555));
CHECK(AJ_MarshalCloseContainer(&txMsg, &struct1));
CHECK(AJ_MarshalArgs(&txMsg, "yyy", 1, 2, 3));
break;
case 2:
CHECK(AJ_MarshalContainer(&txMsg, &array1, AJ_ARG_ARRAY));
for (u = 0; u < ArraySize(Fruits); ++u) {
CHECK(AJ_MarshalContainer(&txMsg, &struct1, AJ_ARG_STRUCT));
CHECK(AJ_MarshalArgs(&txMsg, "us", u, Fruits[u]));
CHECK(AJ_MarshalArg(&txMsg, AJ_InitArg(&arg, AJ_ARG_BYTE, AJ_ARRAY_FLAG, Data8, u)));
CHECK(AJ_MarshalCloseContainer(&txMsg, &struct1));
}
if (status == AJ_OK) {
CHECK(AJ_MarshalCloseContainer(&txMsg, &array1));
}
break;
case 3:
CHECK(AJ_MarshalContainer(&txMsg, &array1, AJ_ARG_ARRAY));
for (j = 0; j < 3; ++j) {
CHECK(AJ_MarshalContainer(&txMsg, &array2, AJ_ARG_ARRAY));
for (k = j; k < ArraySize(Fruits); ++k) {
CHECK(AJ_MarshalArgs(&txMsg, "s", Fruits[k]));
}
CHECK(AJ_MarshalCloseContainer(&txMsg, &array2));
}
if (status == AJ_OK) {
CHECK(AJ_MarshalCloseContainer(&txMsg, &array1));
}
break;
case 4:
CHECK(AJ_MarshalArgs(&txMsg, "i", 987654321));
CHECK(AJ_MarshalVariant(&txMsg, "a(ii)"));
CHECK(AJ_MarshalContainer(&txMsg, &array1, AJ_ARG_ARRAY));
for (j = 0; j < 16; ++j) {
CHECK(AJ_MarshalContainer(&txMsg, &struct1, AJ_ARG_STRUCT));
CHECK(AJ_MarshalArgs(&txMsg, "ii", j + 1, (j + 1) * 100));
CHECK(AJ_MarshalCloseContainer(&txMsg, &struct1));
}
if (status == AJ_OK) {
CHECK(AJ_MarshalCloseContainer(&txMsg, &array1));
}
CHECK(AJ_MarshalArgs(&txMsg, "i", 123456789));
break;
case 5:
CHECK(AJ_MarshalVariant(&txMsg, "(ivi)"));
CHECK(AJ_MarshalContainer(&txMsg, &struct1, AJ_ARG_STRUCT));
CHECK(AJ_MarshalArgs(&txMsg, "i", 1212121));
CHECK(AJ_MarshalVariant(&txMsg, "s"));
CHECK(AJ_MarshalArgs(&txMsg, "s", "inner variant"));
CHECK(AJ_MarshalArgs(&txMsg, "i", 3434343));
CHECK(AJ_MarshalCloseContainer(&txMsg, &struct1));
break;
case 6:
CHECK(AJ_MarshalVariant(&txMsg, "v"));
CHECK(AJ_MarshalVariant(&txMsg, "v"));
CHECK(AJ_MarshalVariant(&txMsg, "v"));
CHECK(AJ_MarshalVariant(&txMsg, "v"));
CHECK(AJ_MarshalVariant(&txMsg, "s"));
CHECK(AJ_MarshalArgs(&txMsg, "s", "deep variant"));
break;
case 7:
CHECK(AJ_MarshalContainer(&txMsg, &struct1, AJ_ARG_STRUCT));
CHECK(AJ_MarshalVariant(&txMsg, "i"));
CHECK(AJ_MarshalArgs(&txMsg, "i", 1212121));
CHECK(AJ_MarshalVariant(&txMsg, "s"));
CHECK(AJ_MarshalArgs(&txMsg, "s", "variant"));
CHECK(AJ_MarshalVariant(&txMsg, "ay"));
CHECK(AJ_MarshalArg(&txMsg, AJ_InitArg(&arg, AJ_ARG_BYTE, AJ_ARRAY_FLAG, Data8, sizeof(Data8))));
CHECK(AJ_MarshalVariant(&txMsg, "aq"));
CHECK(AJ_MarshalArg(&txMsg, AJ_InitArg(&arg, AJ_ARG_UINT16, AJ_ARRAY_FLAG, Data16, sizeof(Data16))));
CHECK(AJ_MarshalCloseContainer(&txMsg, &struct1));
break;
case 8:
CHECK(AJ_MarshalArgs(&txMsg, "uq", 0xF00F00F0, 0x0707));
len = 5000;
CHECK(AJ_DeliverMsgPartial(&txMsg, len + 4));
CHECK(AJ_MarshalRaw(&txMsg, &len, 4));
for (j = 0; j < len; ++j) {
uint8_t n = (uint8_t)j;
CHECK(AJ_MarshalRaw(&txMsg, &n, 1));
}
break;
case 9:
len = 500;
u = len * sizeof(TestStruct);
CHECK(AJ_DeliverMsgPartial(&txMsg, u + sizeof(u) + 4));
CHECK(AJ_MarshalRaw(&txMsg, &u, sizeof(u)));
/*
* Structs are always 8 byte aligned
*/
u = 0;
CHECK(AJ_MarshalRaw(&txMsg, &u, 4));
for (j = 0; j < len; ++j) {
TestStruct ts;
ts.a = j;
ts.b = j + 1;
ts.c = j + 2;
ts.d = j + 3;
CHECK(AJ_MarshalRaw(&txMsg, &ts, sizeof(ts)));
}
break;
case 10:
CHECK(AJ_MarshalContainer(&txMsg, &array1, AJ_ARG_ARRAY));
CHECK(AJ_MarshalCloseContainer(&txMsg, &array1));
break;
case 11:
CHECK(AJ_MarshalArgs(&txMsg, "y", 127));
CHECK(AJ_MarshalContainer(&txMsg, &array1, AJ_ARG_ARRAY));
for (key = 0; key < ArraySize(Colors); ++key) {
AJ_Arg dict;
CHECK(AJ_MarshalContainer(&txMsg, &dict, AJ_ARG_DICT_ENTRY));
CHECK(AJ_MarshalArgs(&txMsg, "ss", Colors[key], Fruits[key]));
CHECK(AJ_MarshalCloseContainer(&txMsg, &dict));
}
if (status == AJ_OK) {
CHECK(AJ_MarshalCloseContainer(&txMsg, &array1));
}
break;
case 12:
CHECK(AJ_MarshalArgs(&txMsg, "y", 0x11));
CHECK(AJ_MarshalArgs(&txMsg, "y", 0x22));
CHECK(AJ_MarshalArgs(&txMsg, "y", 0x33));
CHECK(AJ_MarshalArgs(&txMsg, "y", 0x44));
CHECK(AJ_MarshalArgs(&txMsg, "y", 0x55));
CHECK(AJ_MarshalContainer(&txMsg, &array1, AJ_ARG_ARRAY));
for (key = 0; key < ArraySize(Colors); ++key) {
AJ_Arg dict;
CHECK(AJ_MarshalContainer(&txMsg, &dict, AJ_ARG_DICT_ENTRY));
CHECK(AJ_MarshalArgs(&txMsg, "ys", (uint8_t)key, Colors[key]));
CHECK(AJ_MarshalCloseContainer(&txMsg, &dict));
}
if (status == AJ_OK) {
CHECK(AJ_MarshalCloseContainer(&txMsg, &array1));
}
break;
case 13:
CHECK(AJ_MarshalContainer(&txMsg, &struct1, AJ_ARG_STRUCT));
CHECK(AJ_MarshalArgs(&txMsg, "i", 3434343));
CHECK(AJ_MarshalArg(&txMsg, AJ_InitArg(&arg, AJ_ARG_BYTE, AJ_ARRAY_FLAG, Data8, sizeof(Data8))));
CHECK(AJ_MarshalCloseContainer(&txMsg, &struct1));
break;
}
if (status != AJ_OK) {
AJ_Printf("Failed %d\n", i);
break;
}
AJ_Printf("deliver\n");
AJ_DeliverMsg(&txMsg);
status = AJ_UnmarshalMsg(&bus, &rxMsg, 0);
if (status != AJ_OK) {
break;
}
switch (i) {
case 0:
CHECK(AJ_UnmarshalContainer(&rxMsg, &array1, AJ_ARG_ARRAY));
while (TRUE) {
char* fruit;
AJ_Arg dict;
CHECK(AJ_UnmarshalContainer(&rxMsg, &dict, AJ_ARG_DICT_ENTRY));
CHECK(AJ_UnmarshalArgs(&rxMsg, "us", &key, &fruit));
AJ_Printf("Unmarshal[%d] = %s\n", key, fruit);
CHECK(AJ_UnmarshalCloseContainer(&rxMsg, &dict));
}
/*
* We expect AJ_ERR_NO_MORE
*/
if (status == AJ_ERR_NO_MORE) {
CHECK(AJ_UnmarshalCloseContainer(&rxMsg, &array1));
}
break;
case 1:
CHECK(AJ_UnmarshalArgs(&rxMsg, "u", &u));
AJ_Printf("Unmarshal %u\n", u);
CHECK(AJ_UnmarshalContainer(&rxMsg, &struct1, AJ_ARG_STRUCT));
CHECK(AJ_UnmarshalArgs(&rxMsg, "usu", &u, &str, &v));
AJ_Printf("Unmarshal %u %s %u\n", u, str, v);
CHECK(AJ_UnmarshalContainer(&rxMsg, &struct2, AJ_ARG_STRUCT));
CHECK(AJ_UnmarshalArgs(&rxMsg, "ii", &n, &m));
AJ_Printf("Unmarshal %d %d\n", n, m);
CHECK(AJ_UnmarshalCloseContainer(&rxMsg, &struct2));
CHECK(AJ_UnmarshalArgs(&rxMsg, "qsq", &q, &str, &r));
AJ_Printf("Unmarshal %u %s %u\n", q, str, r);
CHECK(AJ_UnmarshalCloseContainer(&rxMsg, &struct1));
CHECK(AJ_UnmarshalArgs(&rxMsg, "y", &y));
AJ_Printf("Unmarshal %d\n", y);
CHECK(AJ_UnmarshalArgs(&rxMsg, "y", &y));
AJ_Printf("Unmarshal %d\n", y);
CHECK(AJ_UnmarshalArgs(&rxMsg, "y", &y));
AJ_Printf("Unmarshal %d\n", y);
break;
case 2:
CHECK(AJ_UnmarshalContainer(&rxMsg, &array1, AJ_ARG_ARRAY));
while (status == AJ_OK) {
CHECK(AJ_UnmarshalContainer(&rxMsg, &struct1, AJ_ARG_STRUCT));
CHECK(AJ_UnmarshalArgs(&rxMsg, "us", &u, &str));
CHECK(AJ_UnmarshalArg(&rxMsg, &arg));
CHECK(AJ_UnmarshalCloseContainer(&rxMsg, &struct1));
}
/*
* We expect AJ_ERR_NO_MORE
*/
if (status == AJ_ERR_NO_MORE) {
CHECK(AJ_UnmarshalCloseContainer(&rxMsg, &array1));
}
break;
case 3:
CHECK(AJ_UnmarshalContainer(&rxMsg, &array1, AJ_ARG_ARRAY));
while (status == AJ_OK) {
CHECK(AJ_UnmarshalContainer(&rxMsg, &array2, AJ_ARG_ARRAY));
while (status == AJ_OK) {
CHECK(AJ_UnmarshalArg(&rxMsg, &arg));
AJ_Printf("Unmarshal %s\n", arg.val.v_string);
}
/*
* We expect AJ_ERR_NO_MORE
*/
if (status == AJ_ERR_NO_MORE) {
CHECK(AJ_UnmarshalCloseContainer(&rxMsg, &array2));
}
}
/*
* We expect AJ_ERR_NO_MORE
*/
if (status == AJ_ERR_NO_MORE) {
CHECK(AJ_UnmarshalCloseContainer(&rxMsg, &array1));
}
break;
case 4:
CHECK(AJ_UnmarshalArgs(&rxMsg, "i", &j));
AJ_Printf("Unmarshal %d\n", j);
CHECK(AJ_UnmarshalVariant(&rxMsg, (const char**)&sig));
AJ_Printf("Unmarshal variant %s\n", sig);
CHECK(AJ_UnmarshalContainer(&rxMsg, &array1, AJ_ARG_ARRAY));
while (status == AJ_OK) {
CHECK(AJ_UnmarshalContainer(&rxMsg, &struct1, AJ_ARG_STRUCT));
CHECK(AJ_UnmarshalArgs(&rxMsg, "ii", &j, &k));
AJ_Printf("Unmarshal[%d] %d\n", j, k);
CHECK(AJ_UnmarshalCloseContainer(&rxMsg, &struct1));
}
/*
* We expect AJ_ERR_NO_MORE
*/
if (status != AJ_ERR_NO_MORE) {
break;
}
CHECK(AJ_UnmarshalCloseContainer(&rxMsg, &array1));
CHECK(AJ_UnmarshalArgs(&rxMsg, "i", &j));
AJ_Printf("Unmarshal %d\n", j);
break;
case 5:
CHECK(AJ_UnmarshalVariant(&rxMsg, (const char**)&sig));
AJ_Printf("Unmarshal variant %s\n", sig);
CHECK(AJ_UnmarshalContainer(&rxMsg, &struct1, AJ_ARG_STRUCT));
CHECK(AJ_UnmarshalArgs(&rxMsg, "i", &j));
AJ_Printf("Unmarshal %d\n", j);
CHECK(AJ_UnmarshalVariant(&rxMsg, (const char**)&sig));
AJ_Printf("Unmarshal variant %s\n", sig);
CHECK(AJ_UnmarshalArgs(&rxMsg, "s", &str));
AJ_Printf("Unmarshal %s\n", str);
CHECK(AJ_UnmarshalArgs(&rxMsg, "i", &j));
AJ_Printf("Unmarshal %d\n", j);
CHECK(AJ_UnmarshalCloseContainer(&rxMsg, &struct1));
break;
case 6:
CHECK(AJ_UnmarshalVariant(&rxMsg, (const char**)&sig));
AJ_Printf("Unmarshal variant %s\n", sig);
CHECK(AJ_UnmarshalVariant(&rxMsg, (const char**)&sig));
AJ_Printf("Unmarshal variant %s\n", sig);
CHECK(AJ_UnmarshalVariant(&rxMsg, (const char**)&sig));
AJ_Printf("Unmarshal variant %s\n", sig);
CHECK(AJ_UnmarshalVariant(&rxMsg, (const char**)&sig));
AJ_Printf("Unmarshal variant %s\n", sig);
CHECK(AJ_UnmarshalVariant(&rxMsg, (const char**)&sig));
AJ_Printf("Unmarshal variant %s\n", sig);
CHECK(AJ_UnmarshalArgs(&rxMsg, "s", &str));
AJ_Printf("Unmarshal %s\n", str);
break;
case 7:
CHECK(AJ_UnmarshalContainer(&rxMsg, &struct1, AJ_ARG_STRUCT));
CHECK(AJ_UnmarshalVariant(&rxMsg, (const char**)&sig));
AJ_Printf("Unmarshal variant %s\n", sig);
CHECK(AJ_UnmarshalArgs(&rxMsg, "i", &j));
AJ_Printf("Unmarshal %d\n", j);
CHECK(AJ_UnmarshalVariant(&rxMsg, (const char**)&sig));
AJ_Printf("Unmarshal variant %s\n", sig);
CHECK(AJ_UnmarshalArgs(&rxMsg, "s", &str));
CHECK(AJ_UnmarshalVariant(&rxMsg, (const char**)&sig));
AJ_Printf("Unmarshal variant %s\n", sig);
CHECK(AJ_UnmarshalArg(&rxMsg, &arg));
CHECK(AJ_UnmarshalVariant(&rxMsg, (const char**)&sig));
AJ_Printf("Unmarshal variant %s\n", sig);
CHECK(AJ_UnmarshalArg(&rxMsg, &arg));
CHECK(AJ_UnmarshalCloseContainer(&rxMsg, &struct1));
break;
case 8:
CHECK(AJ_UnmarshalArgs(&rxMsg, "uq", &j, &q));
AJ_Printf("Unmarshal %x\n", j);
AJ_Printf("Unmarshal %x\n", q);
CHECK(AJ_UnmarshalRaw(&rxMsg, (const void**)&raw, sizeof(len), &sz));
len = *((uint32_t*)raw);
AJ_Printf("UnmarshalRaw %d\n", len);
for (j = 0; j < len; ++j) {
uint8_t v;
CHECK(AJ_UnmarshalRaw(&rxMsg, (const void**)&raw, 1, &sz));
v = *((uint8_t*)raw);
if (v != (uint8_t)j) {
status = AJ_ERR_FAILURE;
break;
}
}
break;
case 9:
CHECK(AJ_UnmarshalRaw(&rxMsg, (const void**)&raw, 4, &sz));
len = *((uint32_t*)raw) / sizeof(TestStruct);
/*
* Structs are always 8 byte aligned
*/
CHECK(AJ_UnmarshalRaw(&rxMsg, (const void**)&raw, 4, &sz));
for (j = 0; j < len; ++j) {
TestStruct* ts;
CHECK(AJ_UnmarshalRaw(&rxMsg, (const void**)&ts, sizeof(TestStruct), &sz));
if ((ts->a != j) || (ts->b != (j + 1)) || (ts->c != (j + 2)) || (ts->d != (j + 3))) {
status = AJ_ERR_FAILURE;
break;
}
}
break;
case 10:
CHECK(AJ_UnmarshalContainer(&rxMsg, &array1, AJ_ARG_ARRAY));
status = AJ_UnmarshalArg(&rxMsg, &arg);
/*
* We expect AJ_ERR_NO_MORE
*/
if (status == AJ_ERR_NO_MORE) {
CHECK(AJ_UnmarshalCloseContainer(&rxMsg, &array1));
}
break;
case 11:
CHECK(AJ_UnmarshalArgs(&rxMsg, "y", &y));
CHECK(AJ_UnmarshalContainer(&rxMsg, &array1, AJ_ARG_ARRAY));
while (TRUE) {
AJ_Arg dict;
char* fruit;
char* color;
CHECK(AJ_UnmarshalContainer(&rxMsg, &dict, AJ_ARG_DICT_ENTRY));
CHECK(AJ_UnmarshalArgs(&rxMsg, "ss", &color, &fruit));
AJ_Printf("Unmarshal[%s] = %s\n", color, fruit);
CHECK(AJ_UnmarshalCloseContainer(&rxMsg, &dict));
}
/*
* We expect AJ_ERR_NO_MORE
*/
if (status == AJ_ERR_NO_MORE) {
CHECK(AJ_UnmarshalCloseContainer(&rxMsg, &array1));
}
break;
case 12:
CHECK(AJ_UnmarshalArgs(&rxMsg, "y", &y));
CHECK(AJ_UnmarshalArgs(&rxMsg, "y", &y));
CHECK(AJ_UnmarshalArgs(&rxMsg, "y", &y));
CHECK(AJ_UnmarshalArgs(&rxMsg, "y", &y));
CHECK(AJ_UnmarshalArgs(&rxMsg, "y", &y));
CHECK(AJ_UnmarshalContainer(&rxMsg, &array1, AJ_ARG_ARRAY));
while (TRUE) {
AJ_Arg dict;
char* color;
CHECK(AJ_UnmarshalContainer(&rxMsg, &dict, AJ_ARG_DICT_ENTRY));
CHECK(AJ_UnmarshalArgs(&rxMsg, "ys", &y, &color));
AJ_Printf("Unmarshal[%d] = %s\n", y, color);
CHECK(AJ_UnmarshalCloseContainer(&rxMsg, &dict));
}
/*
* We expect AJ_ERR_NO_MORE
*/
if (status == AJ_ERR_NO_MORE) {
CHECK(AJ_UnmarshalCloseContainer(&rxMsg, &array1));
}
break;
case 13:
CHECK(AJ_UnmarshalContainer(&rxMsg, &struct1, AJ_ARG_STRUCT));
CHECK(AJ_UnmarshalArgs(&rxMsg, "i", &n));
AJ_ASSERT(n == 3434343);
CHECK(AJ_UnmarshalArg(&rxMsg, &arg));
for (j = 0; j < arg.len; ++j) {
uint8_t val = arg.val.v_byte[j];
AJ_Printf("Unmarhsalled array1[%u] = %u\n", j, val);
AJ_ASSERT(val == Data8[j]);
}
CHECK(AJ_UnmarshalCloseContainer(&rxMsg, &struct1));
break;
}
if (status != AJ_OK) {
AJ_Printf("Failed %d\n", i);
break;
}
AJ_CloseMsg(&rxMsg);
AJ_Printf("Passed %d\n", i);
}
if (status != AJ_OK) {
AJ_Printf("Marshal/Unmarshal unit test[%d] failed %d\n", i, status);
}
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(): Blacklisting routing node, uniqueName.len = %d\n", uniqueName.len));
AddRoutingNodeToBlacklist(service, AJ_ADDR_UDP4);
status = AJ_ERR_ACCESS_ROUTING_NODE;
} 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()));
// add to blacklist because of invalid version
AddRoutingNodeToBlacklist(service, AJ_ADDR_UDP4);
status = AJ_ERR_OLD_VERSION;
}
}
} else {
status = AJ_ERR_CONNECT;
}
AJ_CloseMsg(&helloResponse);
// reset the transmit queue!
AJ_IO_BUF_RESET(&bus->sock.tx);
if (status == AJ_OK) {
// ARDP does not require additional authentication
bus->isAuthenticated = TRUE;
// ARDP does not require ProbeReq/ProbeAck
bus->isProbeRequired = FALSE;
}
return status;
}
int AJ_Main(void)
{
AJ_Status status = AJ_OK;
AJ_BusAttachment bus;
uint8_t connected = FALSE;
uint32_t sessionId = 0;
AJ_Status authStatus = AJ_ERR_NULL;
/*
* One time initialization before calling any other AllJoyn APIs
*/
AJ_Initialize();
AJ_PrintXML(ProxyObjects);
AJ_RegisterObjects(NULL, ProxyObjects);
while (TRUE) {
AJ_Message msg;
if (!connected) {
status = AJ_StartClient(&bus, NULL, CONNECT_TIMEOUT, FALSE, ServiceName, ServicePort, &sessionId, NULL);
if (status == AJ_OK) {
AJ_Printf("StartClient returned %d, sessionId=%u\n", status, sessionId);
AJ_Printf("Connected to Daemon:%s\n", AJ_GetUniqueName(&bus));
connected = TRUE;
#ifdef SECURE_INTERFACE
AJ_BusSetPasswordCallback(&bus, PasswordCallback);
status = AJ_BusAuthenticatePeer(&bus, ServiceName, AuthCallback, &authStatus);
if (status != AJ_OK) {
AJ_Printf("AJ_BusAuthenticatePeer returned %d\n", status);
}
#else
authStatus = AJ_OK;
#endif
} else {
AJ_Printf("StartClient returned %d\n", status);
break;
}
}
if (authStatus != AJ_ERR_NULL) {
if (authStatus != AJ_OK) {
AJ_Disconnect(&bus);
break;
}
authStatus = AJ_ERR_NULL;
AJ_BusSetLinkTimeout(&bus, sessionId, 10 * 1000);
}
status = AJ_UnmarshalMsg(&bus, &msg, UNMARSHAL_TIMEOUT);
if (status != AJ_OK) {
if (status == AJ_ERR_TIMEOUT) {
AppDoWork(&bus, sessionId);
continue;
}
} else {
switch (msg.msgId) {
case AJ_REPLY_ID(AJ_METHOD_SET_LINK_TIMEOUT):
{
uint32_t disposition;
uint32_t timeout;
status = AJ_UnmarshalArgs(&msg, "uu", &disposition, &timeout);
if (disposition == AJ_SETLINKTIMEOUT_SUCCESS) {
AJ_Printf("Link timeout set to %d\n", timeout);
} else {
AJ_Printf("SetLinkTimeout failed %d\n", disposition);
}
SendPing(&bus, sessionId, 1);
}
break;
case AJ_REPLY_ID(PRX_MY_PING):
{
AJ_Arg arg;
AJ_UnmarshalArg(&msg, &arg);
status = SendGetProp(&bus, sessionId);
}
break;
case AJ_REPLY_ID(PRX_GET_PROP):
{
const char* sig;
status = AJ_UnmarshalVariant(&msg, &sig);
if (status == AJ_OK) {
status = AJ_UnmarshalArgs(&msg, sig, &g_iterCount);
AJ_Printf("Get prop reply %d\n", g_iterCount);
if (status == AJ_OK) {
g_iterCount = g_iterCount + 1;
status = SendSetProp(&bus, sessionId, g_iterCount);
}
}
}
break;
case AJ_REPLY_ID(PRX_SET_PROP):
AJ_Printf("Set prop reply\n");
break;
case AJ_SIGNAL_SESSION_LOST_WITH_REASON:
/*
* Force a disconnect
*/
{
uint32_t id, reason;
AJ_UnmarshalArgs(&msg, "uu", &id, &reason);
AJ_Printf("Session lost. ID = %u, reason = %u", id, reason);
}
status = AJ_ERR_SESSION_LOST;
break;
default:
/*
* Pass to the built-in handlers
*/
status = AJ_BusHandleBusMessage(&msg);
break;
}
}
/*
* Messages must be closed to free resources
*/
AJ_CloseMsg(&msg);
if ((status == AJ_ERR_SESSION_LOST) || (status == AJ_ERR_READ) || (status == AJ_ERR_LINK_DEAD)) {
AJ_Printf("AllJoyn disconnect\n");
AJ_Printf("Disconnected from Daemon:%s\n", AJ_GetUniqueName(&bus));
AJ_Disconnect(&bus);
return status;
}
}
AJ_Printf("clientlite EXIT %d\n", status);
return status;
}
int AJ_Main()
#endif
{
AJ_Status status = AJ_OK;
AJ_BusAttachment bus;
uint8_t connected = FALSE;
uint32_t sessionId = 0;
AJ_Status authStatus = AJ_ERR_NULL;
#ifdef SECURE_INTERFACE
uint32_t suites[AJ_AUTH_SUITES_NUM];
size_t numsuites = 0;
uint8_t clearkeys = FALSE;
#endif
#ifdef MAIN_ALLOWS_ARGS
#if defined(SECURE_INTERFACE) || defined(SECURE_OBJECT)
ac--;
av++;
/*
* Enable authentication mechanism by command line
*/
if (ac) {
if (0 == strncmp(*av, "-ek", 3)) {
clearkeys = TRUE;
ac--;
av++;
} else if (0 == strncmp(*av, "-e", 2)) {
ac--;
av++;
}
if (!ac) {
AJ_AlwaysPrintf(("-e(k) requires an auth mechanism.\n"));
return 1;
}
while (ac) {
if (0 == strncmp(*av, "ECDHE_ECDSA", 11)) {
suites[numsuites++] = AUTH_SUITE_ECDHE_ECDSA;
} else if (0 == strncmp(*av, "ECDHE_PSK", 9)) {
suites[numsuites++] = AUTH_SUITE_ECDHE_PSK;
} else if (0 == strncmp(*av, "ECDHE_NULL", 10)) {
suites[numsuites++] = AUTH_SUITE_ECDHE_NULL;
}
ac--;
av++;
}
}
#endif
#else
suites[numsuites++] = AUTH_SUITE_ECDHE_ECDSA;
clearkeys = TRUE;
#endif
#ifdef SECURE_INTERFACE
if (numsuites == 0) {
/* Default security to ECDHE_NULL, if not explicit elsewhere */
suites[numsuites++] = AUTH_SUITE_ECDHE_NULL;
}
#endif
/*
* One time initialization before calling any other AllJoyn APIs
*/
AJ_Initialize();
AJ_PrintXML(ProxyObjects);
AJ_RegisterObjects(NULL, ProxyObjects);
while (TRUE) {
AJ_Message msg;
if (!connected) {
#if defined (ANNOUNCE_BASED_DISCOVERY)
status = AJ_StartClientByPeerDescription(&bus, NULL, CONNECT_TIMEOUT, FALSE, &pingServicePeer, testServicePort, &sessionId, g_peerServiceName, NULL);
#elif defined (NGNS)
status = AJ_StartClientByInterface(&bus, NULL, CONNECT_TIMEOUT, FALSE, testInterfaceNames, &sessionId, g_peerServiceName, NULL);
#else
status = AJ_StartClientByName(&bus, NULL, CONNECT_TIMEOUT, FALSE, testServiceName, testServicePort, &sessionId, NULL, g_peerServiceName);
#endif
if (status == AJ_OK) {
AJ_AlwaysPrintf(("StartClient returned %d, sessionId=%u, serviceName=%s\n", status, sessionId, g_peerServiceName));
AJ_AlwaysPrintf(("Connected to Daemon:%s\n", AJ_GetUniqueName(&bus)));
connected = TRUE;
#if defined(SECURE_INTERFACE) || defined(SECURE_OBJECT)
AJ_BusEnableSecurity(&bus, suites, numsuites);
AJ_BusSetAuthListenerCallback(&bus, AuthListenerCallback);
if (clearkeys) {
AJ_ClearCredentials(AJ_GENERIC_MASTER_SECRET | AJ_CRED_TYPE_GENERIC);
AJ_ClearCredentials(AJ_GENERIC_ECDSA_MANIFEST | AJ_CRED_TYPE_GENERIC);
AJ_ClearCredentials(AJ_GENERIC_ECDSA_KEYS | AJ_CRED_TYPE_GENERIC);
}
status = AJ_BusAuthenticatePeer(&bus, g_peerServiceName, AuthCallback, &authStatus);
if (status != AJ_OK) {
AJ_AlwaysPrintf(("AJ_BusAuthenticatePeer returned %d\n", status));
}
#else
authStatus = AJ_OK;
#endif
} else {
AJ_AlwaysPrintf(("StartClient returned %d\n", status));
break;
}
}
AJ_AlwaysPrintf(("Auth status %d and AllJoyn status %d\n", authStatus, status));
if (status == AJ_ERR_RESOURCES) {
AJ_InfoPrintf(("Peer is busy, disconnecting and retrying auth...\n"));
AJ_Disconnect(&bus);
connected = FALSE;
continue;
}
if (authStatus != AJ_ERR_NULL) {
if (authStatus != AJ_OK) {
AJ_Disconnect(&bus);
break;
}
authStatus = AJ_ERR_NULL;
AJ_BusSetLinkTimeout(&bus, sessionId, 10 * 1000);
}
status = AJ_UnmarshalMsg(&bus, &msg, UNMARSHAL_TIMEOUT);
if (status != AJ_OK) {
if (status == AJ_ERR_TIMEOUT) {
AppDoWork(&bus, sessionId, g_peerServiceName);
continue;
}
} else {
switch (msg.msgId) {
case AJ_REPLY_ID(AJ_METHOD_SET_LINK_TIMEOUT):
{
uint32_t disposition;
uint32_t timeout;
status = AJ_UnmarshalArgs(&msg, "uu", &disposition, &timeout);
if (disposition == AJ_SETLINKTIMEOUT_SUCCESS) {
AJ_AlwaysPrintf(("Link timeout set to %d\n", timeout));
} else {
AJ_AlwaysPrintf(("SetLinkTimeout failed %d\n", disposition));
}
SendPing(&bus, sessionId, g_peerServiceName, 1);
}
break;
case AJ_REPLY_ID(AJ_METHOD_BUS_PING):
{
uint32_t disposition;
status = AJ_UnmarshalArgs(&msg, "u", &disposition);
if (disposition == AJ_PING_SUCCESS) {
AJ_AlwaysPrintf(("Bus Ping reply received\n"));
} else {
AJ_AlwaysPrintf(("Bus Ping failed, disconnecting: %d\n", disposition));
status = AJ_ERR_LINK_DEAD;
}
}
break;
case AJ_REPLY_ID(PRX_MY_PING):
{
AJ_Arg arg;
AJ_UnmarshalArg(&msg, &arg);
AJ_AlwaysPrintf(("Got ping reply\n"));
AJ_InfoPrintf(("INFO Got ping reply\n"));
status = SendGetProp(&bus, sessionId, g_peerServiceName);
}
break;
case AJ_REPLY_ID(PRX_GET_PROP):
{
const char* sig;
status = AJ_UnmarshalVariant(&msg, &sig);
if (status == AJ_OK) {
status = AJ_UnmarshalArgs(&msg, sig, &g_iterCount);
AJ_AlwaysPrintf(("Get prop reply %d\n", g_iterCount));
if (status == AJ_OK) {
g_iterCount = g_iterCount + 1;
status = SendSetProp(&bus, sessionId, g_peerServiceName, g_iterCount);
}
}
}
break;
case AJ_REPLY_ID(PRX_SET_PROP):
AJ_AlwaysPrintf(("Set prop reply\n"));
break;
case AJ_SIGNAL_SESSION_LOST_WITH_REASON:
/*
* Force a disconnect
*/
{
uint32_t id, reason;
AJ_UnmarshalArgs(&msg, "uu", &id, &reason);
AJ_AlwaysPrintf(("Session lost. ID = %u, reason = %u\n", id, reason));
}
status = AJ_ERR_SESSION_LOST;
break;
default:
/*
* Pass to the built-in handlers
*/
status = AJ_BusHandleBusMessage(&msg);
break;
}
}
/*
* Messages must be closed to free resources
*/
AJ_CloseMsg(&msg);
if ((status == AJ_ERR_SESSION_LOST) || (status == AJ_ERR_READ) || (status == AJ_ERR_WRITE) || (status == AJ_ERR_LINK_DEAD)) {
AJ_AlwaysPrintf(("AllJoyn disconnect\n"));
AJ_AlwaysPrintf(("Disconnected from Daemon:%s\n", AJ_GetUniqueName(&bus)));
AJ_Disconnect(&bus);
break;
}
}
AJ_AlwaysPrintf(("clientlite EXIT %d\n", status));
return status;
}
int AJ_Main()
{
// you're connected now, so print out the data:
AJ_AlwaysPrintf(("You're connected to the network\n"));
AJ_Initialize();
AJ_PrintXML(AppObjects);
AJ_RegisterObjects(AppObjects, NULL);
while (TRUE) {
AJ_Message msg;
if (!connected) {
status = AJ_StartService(&bus, NULL, CONNECT_TIMEOUT, FALSE, ServicePort, ServiceName, AJ_NAME_REQ_DO_NOT_QUEUE, NULL);
if (status == AJ_OK) {
AJ_AlwaysPrintf(("StartService returned %d\n", status));
connected = TRUE;
if (authenticate) {
AJ_BusSetPasswordCallback(&bus, PasswordCallback);
} else {
authStatus = AJ_OK;
}
} else {
AJ_AlwaysPrintf(("StartClient returned %d\n", status));
continue;
}
}
status = AJ_UnmarshalMsg(&bus, &msg, UNMARSHAL_TIMEOUT);
if (status != AJ_OK) {
if (status == AJ_ERR_TIMEOUT) {
AppDoWork();
continue;
}
}
if (status == AJ_OK) {
switch (msg.msgId) {
case AJ_METHOD_ACCEPT_SESSION:
{
uint16_t port;
char* joiner;
AJ_AlwaysPrintf(("Accepting...\n"));
AJ_UnmarshalArgs(&msg, "qus", &port, &sessionId, &joiner);
status = AJ_BusReplyAcceptSession(&msg, TRUE);
if (status == AJ_OK) {
AJ_AlwaysPrintf(("Accepted session session_id=%u joiner=%s\n", sessionId, joiner));
} else {
AJ_AlwaysPrintf(("AJ_BusReplyAcceptSession: error %d\n", status));
}
}
break;
case APP_MY_CAT:
status = AppHandleCat(&msg);
break;
case AJ_SIGNAL_SESSION_LOST_WITH_REASON:
/*
* don't force a disconnect, be ready to accept another session
*/
{
uint32_t id, reason;
AJ_UnmarshalArgs(&msg, "uu", &id, &reason);
AJ_AlwaysPrintf(("Session lost. ID = %u, reason = %d", id, reason));
}
break;
default:
/*
* Pass to the built-in handlers
*/
status = AJ_BusHandleBusMessage(&msg);
break;
}
}
/*
* Messages must be closed to free resources
*/
AJ_CloseMsg(&msg);
if ((status == AJ_ERR_READ) || (status == AJ_ERR_LINK_DEAD)) {
AJ_AlwaysPrintf(("AllJoyn disconnect\n"));
AJ_Disconnect(&bus);
connected = FALSE;
/*
* Sleep a little while before trying to reconnect
*/
AJ_Sleep(10 * 1000);
}
}
return 0;
}
