AJ_Status SendPing(AJ_BusAttachment* bus, uint32_t sessionId)
{
AJ_Status status;
AJ_Message msg;
AJ_AlwaysPrintf(("Sending ping request '%s'.\n", pingString));
status = AJ_MarshalMethodCall(bus,
&msg,
PRX_PING,
fullServiceName,
sessionId,
AJ_FLAG_ENCRYPTED,
METHOD_TIMEOUT);
if (AJ_OK == status) {
status = AJ_MarshalArgs(&msg, "s", pingString);
} else {
AJ_InfoPrintf(("In SendPing() AJ_MarshalMethodCall() status = %d.\n", status));
}
if (AJ_OK == status) {
status = AJ_DeliverMsg(&msg);
} else {
AJ_InfoPrintf(("In SendPing() AJ_MarshalArgs() status = %d.\n", status));
}
if (AJ_OK != status) {
AJ_InfoPrintf(("In SendPing() AJ_DeliverMsg() status = %d.\n", status));
}
return status;
}
AJ_Status AJ_BusSetSignalRuleSerial(AJ_BusAttachment* bus, const char* ruleString, uint8_t rule, uint8_t flags, uint32_t* serialNum)
{
AJ_Status status;
AJ_Message msg;
uint32_t msgId = (rule == AJ_BUS_SIGNAL_ALLOW) ? AJ_METHOD_ADD_MATCH : AJ_METHOD_REMOVE_MATCH;
AJ_InfoPrintf(("AJ_BusSetSignalRuleSerial(bus=0x%p, ruleString=\"%s\", rule=%d.)\n", bus, ruleString, rule));
status = AJ_MarshalMethodCall(bus, &msg, msgId, AJ_DBusDestination, 0, flags, AJ_METHOD_TIMEOUT);
if (status == AJ_OK) {
uint32_t sz = 0;
uint8_t nul = 0;
if (serialNum) {
*serialNum = msg.hdr->serialNum;
}
sz = (uint32_t)strlen(ruleString);
status = AJ_DeliverMsgPartial(&msg, sz + 5);
AJ_MarshalRaw(&msg, &sz, 4);
AJ_MarshalRaw(&msg, ruleString, strlen(ruleString));
AJ_MarshalRaw(&msg, &nul, 1);
}
if (status == AJ_OK) {
status = AJ_DeliverMsg(&msg);
}
return status;
}
AJ_Status AJ_PeerAuthenticate(AJ_BusAttachment* bus, const char* peerName, AJ_PeerAuthenticateCallback callback, void* cbContext)
{
AJ_Message msg;
char guidStr[33];
AJ_GUID localGuid;
uint32_t version = REQUIRED_AUTH_VERSION;
/*
* Check there isn't an authentication in progress
*/
if (authContext.callback || authContext.peerGuid) {
/*
* The existing authentication may have timed-out
*/
if (AJ_GetElapsedTime(&authContext.timer, TRUE) < MAX_AUTH_TIME) {
return AJ_ERR_RESOURCES;
}
/*
* Report the failed authentication
*/
PeerAuthComplete(AJ_ERR_TIMEOUT);
}
authContext.callback = callback;
authContext.cbContext = cbContext;
authContext.peerName = peerName;
AJ_InitTimer(&authContext.timer);
/*
* Kick off autnetication with an ExchangeGUIDS method call
*/
AJ_MarshalMethodCall(bus, &msg, AJ_METHOD_EXCHANGE_GUIDS, peerName, 0, AJ_NO_FLAGS, CALL_TIMEOUT);
AJ_GetLocalGUID(&localGuid);
AJ_GUID_ToString(&localGuid, guidStr, sizeof(guidStr));
AJ_MarshalArgs(&msg, "su", guidStr, version);
return AJ_DeliverMsg(&msg);
}
AJ_Status AJ_BusAddSignalRule(AJ_BusAttachment* bus, const char* signalName, const char* interfaceName, uint8_t rule)
{
AJ_Status status;
AJ_Message msg;
const char* str[5];
uint32_t msgId = (rule == AJ_BUS_SIGNAL_ALLOW) ? AJ_METHOD_ADD_MATCH : AJ_METHOD_REMOVE_MATCH;
AJ_InfoPrintf(("AJ_BusAddSignalRule(bus=0x%p, signalName=\"%s\", interfaceName=\"%s\", rule=%d.)\n", bus, signalName, interfaceName, rule));
str[0] = "type='signal',member='";
str[1] = signalName;
str[2] = "'interface='";
str[3] = interfaceName;
str[4] = "'";
status = AJ_MarshalMethodCall(bus, &msg, msgId, AJ_DBusDestination, 0, 0, AJ_METHOD_TIMEOUT);
if (status == AJ_OK) {
size_t i;
uint32_t sz = 0;
uint8_t nul = 0;
for (i = 0; i < ArraySize(str); ++i) {
sz += (uint32_t)strlen(str[i]);
}
status = AJ_DeliverMsgPartial(&msg, sz + 5);
AJ_MarshalRaw(&msg, &sz, 4);
for (i = 0; i < ArraySize(str); ++i) {
AJ_MarshalRaw(&msg, str[i], strlen(str[i]));
}
AJ_MarshalRaw(&msg, &nul, 1);
}
if (status == AJ_OK) {
status = AJ_DeliverMsg(&msg);
}
return status;
}
void CPS_IdleConnectedHandler(AJ_BusAttachment*bus)
{
if (runningTestNum == lastTestRun || CPSsessionId == 0) {
return;
}
if (runningTestNum == numTests) {
runningTestNum = 0;
AJ_InfoPrintf(("Finished running all the tests\n"));
exit(0);
}
AJ_Status status;
AJ_Message msg;
status = AJ_MarshalMethodCall(&busAttachment, &msg, testsToRun[runningTestNum].msgId,
announceSender, CPSsessionId, 0, CPSC_CONNECT_TIMEOUT);
uint16_t numParam;
for (numParam = 0; numParam < testsToRun[runningTestNum].numParams; numParam++) {
if (status == AJ_OK) {
status = AJ_MarshalArgs(&msg, "q", testsToRun[runningTestNum].param[numParam]);
}
}
if (status == AJ_OK) {
status = AJ_DeliverMsg(&msg);
lastTestRun = runningTestNum;
}
AJ_InfoPrintf(("MakeMethodCall() test number %i resulted in a status of %s.\n", lastTestRun + 1, AJ_StatusText(status)));
}
AJ_Status AJNS_Consumer_SendDismissRequest(AJ_BusAttachment* busAttachment, uint16_t version, int32_t notificationId, const char* appId, const char* senderName, uint32_t sessionId)
{
AJ_Status status = AJ_OK;
if ((status == AJ_OK) && (sessionId != 0)) {
AJ_Message dismissMsg;
status = AJ_MarshalMethodCall(busAttachment, &dismissMsg, NOTIFICATION_PRODUCER_DISMISS_PROXY, senderName, sessionId, AJ_NO_FLAGS, AJ_CALL_TIMEOUT);
if (status != AJ_OK) {
AJ_ErrPrintf(("Could not marshal method call\n"));
return status;
}
status = AJ_MarshalArgs(&dismissMsg, "i", notificationId);
if (status != AJ_OK) {
AJ_ErrPrintf(("Could not marshal arguments\n"));
return status;
}
status = AJ_DeliverMsg(&dismissMsg);
if (status != AJ_OK) {
AJ_ErrPrintf(("Could not deliver message\n"));
return status;
}
AJ_CloseMsg(&dismissMsg);
}
return status;
}
static AJ_Status SendHello(AJ_BusAttachment* bus)
{
AJ_Status status;
AJ_Message msg;
status = AJ_MarshalMethodCall(bus, &msg, AJ_METHOD_HELLO, AJ_DBusDestination, 0, AJ_FLAG_ALLOW_REMOTE_MSG, 5000);
if (status == AJ_OK) {
status = AJ_DeliverMsg(&msg);
}
return status;
}
AJ_Status SendGetProp(AJ_BusAttachment* bus, uint32_t sessionId)
{
AJ_Status status;
AJ_Message msg;
status = AJ_MarshalMethodCall(bus, &msg, PRX_GET_PROP, ServiceName, sessionId, 0, METHOD_TIMEOUT);
if (status == AJ_OK) {
AJ_MarshalPropertyArgs(&msg, PRX_GET_INT);
status = AJ_DeliverMsg(&msg);
}
return status;
}
AJ_Status AJ_PeerHandleGenSessionKeyReply(AJ_Message* msg)
{
AJ_Status status;
/*
* For 12 bytes of verifier, we need at least 12 * 2 characters
* to store its representation in hex (24 octets + 1 octet for \0).
* However, the KeyGen function demands a bigger buffer
* (to store 16 bytes key in addition to the 12 bytes verifier).
* Hence we allocate, the maximum of (12 * 2 + 1) and (16 + 12).
*/
char verifier[VERIFIER_LEN + AES_KEY_LEN];
char* nonce;
char* remVerifier;
/*
* Check we are in an auth conversation with the sender
*/
status = CheckAuthPeer(msg);
if (status != AJ_OK) {
return status;
}
if (msg->hdr->msgType == AJ_MSG_ERROR) {
status = AJ_ERR_SECURITY;
} else {
AJ_UnmarshalArgs(msg, "ss", &nonce, &remVerifier);
status = KeyGen(msg->sender, AJ_ROLE_KEY_INITIATOR, authContext.nonce, nonce, (uint8_t*)verifier, sizeof(verifier));
if (status == AJ_OK) {
/*
* Check verifier strings match as expected
*/
if (strcmp(remVerifier, verifier) != 0) {
status = AJ_ERR_SECURITY;
}
}
if (status == AJ_OK) {
AJ_Arg key;
AJ_Message call;
uint8_t groupKey[AES_KEY_LEN];
/*
* Group keys are exchanged via an encrypted message
*/
AJ_MarshalMethodCall(msg->bus, &call, AJ_METHOD_EXCHANGE_GROUP_KEYS, msg->sender, 0, AJ_FLAG_ENCRYPTED, CALL_TIMEOUT);
AJ_GetGroupKey(NULL, groupKey);
AJ_MarshalArg(&call, AJ_InitArg(&key, AJ_ARG_BYTE, AJ_ARRAY_FLAG, groupKey, sizeof(groupKey)));
status = AJ_DeliverMsg(&call);
}
}
if (status != AJ_OK) {
PeerAuthComplete(status);
}
return AJ_OK;
}
AJ_Status AJ_BusSetLinkTimeout(AJ_BusAttachment* bus, uint32_t sessionId, uint32_t linkTimeout)
{
AJ_Status status;
AJ_Message msg;
AJ_InfoPrintf(("AJ_BusSetLinkTimeout(bus=0x%p, sessionId=%d., linkTimeout=%d.)\n", bus, sessionId, linkTimeout));
status = AJ_MarshalMethodCall(bus, &msg, AJ_METHOD_SET_LINK_TIMEOUT, AJ_BusDestination, 0, 0, AJ_METHOD_TIMEOUT);
if (status == AJ_OK) {
(void)AJ_MarshalArgs(&msg, "u", sessionId);
(void)AJ_MarshalArgs(&msg, "u", linkTimeout);
status = AJ_DeliverMsg(&msg);
}
return status;
}
AJ_Status AJ_BusLeaveSession(AJ_BusAttachment* bus, uint32_t sessionId)
{
AJ_Status status;
AJ_Message msg;
AJ_InfoPrintf(("AJ_BusLeaveSession(bus=0x%p, sessionId=%d.)\n", bus, sessionId));
status = AJ_MarshalMethodCall(bus, &msg, AJ_METHOD_LEAVE_SESSION, AJ_BusDestination, 0, 0, AJ_METHOD_TIMEOUT);
if (status == AJ_OK) {
status = AJ_MarshalArgs(&msg, "u", sessionId);
}
if (status == AJ_OK) {
status = AJ_DeliverMsg(&msg);
}
return status;
}
AJ_Status AJ_BusUnbindSession(AJ_BusAttachment* bus, uint16_t port)
{
AJ_Status status;
AJ_Message msg;
AJ_InfoPrintf(("AJ_BusUnbindSession(bus=0x%p, port=%d.)\n", bus, port));
status = AJ_MarshalMethodCall(bus, &msg, AJ_METHOD_UNBIND_SESSION, AJ_BusDestination, 0, 0, AJ_METHOD_TIMEOUT);
if (status == AJ_OK) {
AJ_MarshalArgs(&msg, "q", port);
}
if (status == AJ_OK) {
status = AJ_DeliverMsg(&msg);
}
return status;
}
AJ_Status SendGetProp(AJ_BusAttachment* bus, uint32_t sessionId, const char* serviceName)
{
AJ_Status status;
AJ_Message msg;
status = AJ_MarshalMethodCall(bus, &msg, PRX_GET_PROP, serviceName, sessionId, 0, METHOD_TIMEOUT);
if (status == AJ_OK) {
status = AJ_MarshalPropertyArgs(&msg, PRX_GET_INT);
}
if (status == AJ_OK) {
status = AJ_DeliverMsg(&msg);
} else {
AJ_AlwaysPrintf(("SendGetProp %s\n", AJ_StatusText(status)));
}
return status;
}
AJ_Status AJ_BusPing(AJ_BusAttachment* bus, const char* name, uint32_t timeout)
{
AJ_Status status;
AJ_Message msg;
AJ_InfoPrintf(("AJ_BusPing(bus=0x%p, name=%s, timeout=%d)\n", bus, name, timeout));
status = AJ_MarshalMethodCall(bus, &msg, AJ_METHOD_BUS_PING, AJ_BusDestination, 0, 0, AJ_METHOD_TIMEOUT);
if (status == AJ_OK) {
AJ_MarshalArgs(&msg, "su", name, timeout);
}
if (status == AJ_OK) {
status = AJ_DeliverMsg(&msg);
}
return status;
}
AJ_Status AJ_BusCancelSessionless(AJ_BusAttachment* bus, uint32_t serialNum)
{
AJ_Status status;
AJ_Message msg;
AJ_InfoPrintf(("AJ_BusCancelSessionless(bus=0x%p, serialNum=%d.)\n", bus, serialNum));
status = AJ_MarshalMethodCall(bus, &msg, AJ_METHOD_CANCEL_SESSIONLESS, AJ_BusDestination, 0, 0, AJ_METHOD_TIMEOUT);
if (status == AJ_OK) {
AJ_MarshalArgs(&msg, "u", serialNum);
}
if (status == AJ_OK) {
status = AJ_DeliverMsg(&msg);
}
return status;
}
AJ_Status AJ_BusRemoveSessionMember(AJ_BusAttachment* bus, uint32_t sessionId, const char* member)
{
AJ_Status status;
AJ_Message msg;
AJ_InfoPrintf(("AJ_BusRemoveSessionMember(bus=0x%p, sessionId=%d, member=%s.)\n", bus, sessionId, member));
status = AJ_MarshalMethodCall(bus, &msg, AJ_METHOD_REMOVE_SESSION_MEMBER, AJ_BusDestination, 0, 0, AJ_METHOD_TIMEOUT);
if (status == AJ_OK) {
AJ_MarshalArgs(&msg, "us", sessionId, member);
}
if (status == AJ_OK) {
status = AJ_DeliverMsg(&msg);
}
return status;
}
AJ_Status AJ_BusReleaseName(AJ_BusAttachment* bus, const char* name)
{
AJ_Status status;
AJ_Message msg;
AJ_InfoPrintf(("AJ_BusReleaseName(bus=0x%p, name=\"%s\")\n", bus, name));
status = AJ_MarshalMethodCall(bus, &msg, AJ_METHOD_RELEASE_NAME, AJ_BusDestination, 0, 0, AJ_METHOD_TIMEOUT);
if (status == AJ_OK) {
status = AJ_MarshalArgs(&msg, "s", name);
}
if (status == AJ_OK) {
status = AJ_DeliverMsg(&msg);
}
return status;
}
AJ_Status AJ_BusAdvertiseName(AJ_BusAttachment* bus, const char* name, uint16_t transportMask, uint8_t op, uint8_t flags)
{
AJ_Status status;
AJ_Message msg;
uint32_t msgId = (op == AJ_BUS_START_ADVERTISING) ? AJ_METHOD_ADVERTISE_NAME : AJ_METHOD_CANCEL_ADVERTISE;
AJ_InfoPrintf(("AJ_BusAdvertiseName(bus=0x%p, name=\"%s\", transportMask=0x%x, op=%d.)\n", bus, name, transportMask, op));
status = AJ_MarshalMethodCall(bus, &msg, msgId, AJ_BusDestination, 0, flags, AJ_METHOD_TIMEOUT);
if (status == AJ_OK) {
status = AJ_MarshalArgs(&msg, "sq", name, transportMask);
}
if (status == AJ_OK) {
status = AJ_DeliverMsg(&msg);
}
return status;
}
AJ_Status AJ_BusFindAdvertisedNameByTransport(AJ_BusAttachment* bus, const char* namePrefix, uint16_t transport, uint8_t op)
{
AJ_Status status;
AJ_Message msg;
uint32_t msgId = (op == AJ_BUS_START_FINDING) ? AJ_METHOD_FIND_NAME_BY_TRANSPORT : AJ_METHOD_CANCEL_FIND_NAME_BY_TRANSPORT;
AJ_InfoPrintf(("AJ_BusFindAdvertiseNameByTransport(bus=0x%p, namePrefix=\"%s\", transport=%d., op=%d.)\n", bus, namePrefix, transport, op));
status = AJ_MarshalMethodCall(bus, &msg, msgId, AJ_BusDestination, 0, 0, AJ_METHOD_TIMEOUT);
if (status == AJ_OK) {
status = AJ_MarshalArgs(&msg, "sq", namePrefix, transport);
}
if (status == AJ_OK) {
status = AJ_DeliverMsg(&msg);
}
return status;
}
AJ_Status AJ_BusRequestName(AJ_BusAttachment* bus, const char* name, uint32_t flags)
{
AJ_Status status;
AJ_Message msg;
AJ_InfoPrintf(("AJ_BusRequestName(bus=0x%p, name=\"%s\", flags=0x%x)\n", bus, name, flags));
status = AJ_MarshalMethodCall(bus, &msg, AJ_METHOD_REQUEST_NAME, AJ_BusDestination, 0, 0, AJ_METHOD_TIMEOUT);
if (status == AJ_OK) {
status = AJ_MarshalArgs(&msg, "su", name, flags);
}
if (status == AJ_OK) {
status = AJ_DeliverMsg(&msg);
}
return status;
}
AJ_Status AJ_SetIdleTimeouts(AJ_BusAttachment* bus, uint32_t idleTo, uint32_t probeTo)
{
AJ_Status status;
AJ_Message msg;
// AJ_InfoPrintf(("AJ_SetIdleTimeouts(bus=0x%p, idleTo=%d, probeTo=%d)\n", bus, idleTo, probeTo));
status = AJ_MarshalMethodCall(bus, &msg, AJ_METHOD_BUS_SET_IDLE_TIMEOUTS, AJ_BusDestination, 0, 0, AJ_METHOD_TIMEOUT);
if (status == AJ_OK)
{
status = AJ_MarshalArgs(&msg, "uu", idleTo, probeTo);
}
if (status == AJ_OK)
{
status = AJ_DeliverMsg(&msg);
}
return status;
}
static void DoCat()
{
AJ_Status status;
AJ_Message msg;
/*
* Set the object path so we can make a method call
*/
(void)AJ_SetProxyObjectPath(proxyObjects, BASIC_CLIENT_CAT, serviceObjPath);
status = AJ_MarshalMethodCall(&bus, &msg, BASIC_CLIENT_CAT, serviceName, sessionId, 0, METHOD_TIMEOUT);
if (status == AJ_OK) {
status = AJ_MarshalArgs(&msg, "ss", "Hello ", "World!");
}
if (status == AJ_OK) {
status = AJ_DeliverMsg(&msg);
}
AJ_InfoPrintf(("MakeMethodCall() resulted in a status of 0x%04x.\n", status));
}
AJ_Status AJ_BusBindSessionPort(AJ_BusAttachment* bus, uint16_t port, const AJ_SessionOpts* opts, uint8_t flags)
{
AJ_Status status;
AJ_Message msg;
AJ_InfoPrintf(("AJ_BusBindSessionPort(bus=0x%p, port=%d., opts=0x%p)\n", bus, port, opts));
if (!opts) {
opts = &defaultSessionOpts;
}
status = AJ_MarshalMethodCall(bus, &msg, AJ_METHOD_BIND_SESSION_PORT, AJ_BusDestination, 0, flags, AJ_METHOD_TIMEOUT);
if (status == AJ_OK) {
AJ_MarshalArgs(&msg, "q", port);
status = MarshalSessionOpts(&msg, opts);
}
if (status == AJ_OK) {
status = AJ_DeliverMsg(&msg);
}
return status;
}
AJ_Status SendNewName(AJ_BusAttachment* bus, uint32_t sessionId, char*newName)
{
AJ_Status status;
AJ_Message msg;
status = AJ_MarshalMethodCall(bus, &msg, PRX_SET_PROP, ServiceName, sessionId, 0, METHOD_TIMEOUT);
if (status == AJ_OK) {
status = AJ_MarshalPropertyArgs(&msg, PRX_SET_NAME);
if (status == AJ_OK) {
status = AJ_MarshalArgs(&msg, "s", newName);
}
if (status == AJ_OK) {
status = AJ_DeliverMsg(&msg);
}
}
return status;
}
static AJ_Status NameHasOwner(AJ_Message* msg, const char* name, uint32_t* serialNum)
{
AJ_Status status;
AJ_Message call;
// AJ_InfoPrintf(("NameHasOwner(msg=0x%p)\n", msg));
// Ask if name has an owner
status = AJ_MarshalMethodCall(msg->bus, &call, AJ_METHOD_NAME_HAS_OWNER, AJ_DBusDestination, 0, 0, AJ_METHOD_TIMEOUT);
if (status == AJ_OK)
{
*serialNum = call.hdr->serialNum;
status = AJ_MarshalArgs(&call, "s", name);
}
if (status != AJ_OK)
{
AJ_ErrPrintf(("NameHasOwner(msg=0x%p): Marshal error\n", msg));
return status;
}
return AJ_DeliverMsg(&call);
}
AJ_Status SendPing(AJ_BusAttachment* bus, uint32_t sessionId, unsigned int num)
{
AJ_Status status;
AJ_Message msg;
/*
* Since the object path on the proxy object entry was not set in the proxy object table above
* it must be set before marshalling the method call.
*/
status = AJ_SetProxyObjectPath(ProxyObjects, PRX_MY_PING, testObj);
if (status == AJ_OK) {
status = AJ_MarshalMethodCall(bus, &msg, PRX_MY_PING, ServiceName, sessionId, 0, METHOD_TIMEOUT);
}
if (status == AJ_OK) {
status = AJ_MarshalArgs(&msg, "s", PingString);
}
if (status == AJ_OK) {
status = AJ_DeliverMsg(&msg);
}
return status;
}
static AJ_Status AuthResponse(AJ_Message* msg, char* inStr)
{
AJ_Status status;
char* buf;
if (authContext.sasl.state == AJ_SASL_AUTHENTICATED) {
return GenSessionKey(msg);
}
/*
* Need a short-lived buffer to compose the response
*/
buf = (char*)AJ_Malloc(AUTH_BUF_LEN);
if (!buf) {
status = AJ_ERR_RESOURCES;
} else {
status = AJ_SASL_Advance(&authContext.sasl, inStr, buf, AUTH_BUF_LEN);
if (status == AJ_OK) {
AJ_Message call;
AJ_MarshalMethodCall(msg->bus, &call, AJ_METHOD_AUTH_CHALLENGE, msg->sender, 0, AJ_NO_FLAGS, AUTH_CALL_TIMEOUT);
AJ_MarshalArgs(&call, "s", buf);
status = AJ_DeliverMsg(&call);
}
AJ_Free(buf);
}
/*
* If there was an error finalize the auth mechanism
*/
if (status != AJ_OK) {
if (authContext.sasl.mechanism) {
authContext.sasl.mechanism->Final(authContext.peerGuid);
}
/*
* Report authentication failure to application
*/
if (status != AJ_OK) {
PeerAuthComplete(status);
}
}
return status;
}
AJ_Status AJ_BusJoinSession(AJ_BusAttachment* bus, const char* sessionHost, uint16_t port, const AJ_SessionOpts* opts)
{
AJ_Status status;
AJ_Message msg;
AJ_InfoPrintf(("AJ_BusJoinSession(bus=0x%p, sessionHost=\"%s\", port=%d., opts=0x%p)\n", bus, sessionHost, port, opts));
if (!opts) {
opts = &defaultSessionOpts;
}
status = AJ_MarshalMethodCall(bus, &msg, AJ_METHOD_JOIN_SESSION, AJ_BusDestination, 0, 0, AJ_METHOD_TIMEOUT);
if (status == AJ_OK) {
status = AJ_MarshalArgs(&msg, "sq", sessionHost, port);
if (status == AJ_OK) {
status = MarshalSessionOpts(&msg, opts);
}
}
if (status == AJ_OK) {
status = AJ_DeliverMsg(&msg);
}
return status;
}
AJ_Status SendSetProp(AJ_BusAttachment* bus, uint32_t sessionId, int val)
{
AJ_Status status;
AJ_Message msg;
status = AJ_MarshalMethodCall(bus, &msg, PRX_SET_PROP, ServiceName, sessionId, 0, METHOD_TIMEOUT);
if (status == AJ_OK) {
status = AJ_MarshalPropertyArgs(&msg, PRX_SET_INT);
if (status == AJ_OK) {
status = AJ_MarshalArgs(&msg, "i", val);
} else {
AJ_Printf(">>>>>>>>In SendSetProp() AJ_MarshalPropertyArgs() returned status = 0x%04x\n", status);
}
if (status == AJ_OK) {
status = AJ_DeliverMsg(&msg);
} else {
AJ_Printf(">>>>>>>>In SendSetProp() AJ_MarshalArgs() returned status = 0x%04x\n", status);
}
}
return status;
}
static AJ_Status GenSessionKey(AJ_Message* msg)
{
AJ_Message call;
if (authContext.sasl.mechanism) {
authContext.sasl.mechanism->Final(authContext.peerGuid);
}
authContext.sasl.state = AJ_SASL_IDLE;
AJ_MarshalMethodCall(msg->bus, &call, AJ_METHOD_GEN_SESSION_KEY, msg->sender, 0, AJ_NO_FLAGS, CALL_TIMEOUT);
/*
* Marshal local peer GUID, remote peer GUID, and local peer's GUID
*/
{
char guidStr[33];
AJ_GUID localGuid;
AJ_GetLocalGUID(&localGuid);
AJ_GUID_ToString(&localGuid, guidStr, sizeof(guidStr));
AJ_MarshalArgs(&call, "s", guidStr);
AJ_GUID_ToString(authContext.peerGuid, guidStr, sizeof(guidStr));
AJ_RandHex(authContext.nonce, sizeof(authContext.nonce), NONCE_LEN);
AJ_MarshalArgs(&call, "ss", guidStr, authContext.nonce);
}
return AJ_DeliverMsg(&call);
}
