void *FindProvisioningResource(void *data) {
// If user stopped the process before thread get scheduled then check and return from this function;
if (IsSetupStopped()) {
ErrorCallback(DEVICE_NOT_PROVISIONED);
ClearMemory();
return NULL;
}
OCStackResult ret = OC_STACK_ERROR;
OIC_LOG_V(DEBUG, TAG, "szFindResourceQueryUri = %s", szFindResourceQueryUri);
OCCallbackData ocCBData;
ocCBData.cb = FindProvisioningResourceResponse;
ocCBData.context = (void *) EASY_SETUP_DEFAULT_CONTEXT_VALUE;
ocCBData.cd = NULL;
ret = OCDoResource(NULL, OC_REST_DISCOVER, szFindResourceQueryUri, NULL, NULL,
netProvInfo->connType, OC_LOW_QOS,
&ocCBData, NULL, 0);
if (ret != OC_STACK_OK) {
ErrorCallback(DEVICE_NOT_PROVISIONED);
ClearMemory();
}
return NULL;
}
// This is a function called back when a device is discovered
OCStackApplicationResult FindProvisioningResourceResponse(void* /*ctx*/, OCDoHandle /*handle*/,
OCClientResponse *clientResponse)
{
OIC_LOG_V(INFO, ES_WIFI_PROV_TAG, "Entering FindProvisioningResourceResponse %s",
clientResponse->devAddr.addr);
// If user stopped the process then return from this function;
if (IsSetupStopped())
{
ErrorCallback(DEVICE_NOT_PROVISIONED);
ClearMemory();
return OC_STACK_DELETE_TRANSACTION;
}
if (!ValidateFindResourceResponse(clientResponse))
{
ErrorCallback(DEVICE_NOT_PROVISIONED);
return OC_STACK_DELETE_TRANSACTION;
}
char szQueryUri[MAX_QUERY_LENGTH] =
{ 0 };
OCDiscoveryPayload *discoveryPayload = (OCDiscoveryPayload *) (clientResponse->payload);
OIC_LOG_V(DEBUG, ES_WIFI_PROV_TAG, "resUri = %s", discoveryPayload->resources->uri);
#ifdef REMOTE_ARDUINO_ENROLEE
//Arduino Enrollee needs mediator application provide IP and port55555 which is specific
// to Arduino WiFi enrollee
// REMOTE_ARDUINO_ENROLEE has to be defined if Mediator is being tested with Arduino
snprintf(szQueryUri, sizeof(szQueryUri), UNICAST_PROV_STATUS_QUERY,
clientResponse->addr->addr,
IP_PORT,
discoveryPayload->resources->uri);
#else
snprintf(szQueryUri, sizeof(szQueryUri), UNICAST_PROV_STATUS_QUERY,
clientResponse->devAddr.addr, clientResponse->devAddr.port,
discoveryPayload->resources->uri);
#endif
OIC_LOG_V(DEBUG, ES_WIFI_PROV_TAG, "query before GetProvisioningStatus call = %s", szQueryUri);
if (GetProvisioningStatus(OC_HIGH_QOS, szQueryUri, &clientResponse->devAddr) != OC_STACK_OK)
{
ErrorCallback(DEVICE_NOT_PROVISIONED);
return OC_STACK_DELETE_TRANSACTION;
}
return OC_STACK_KEEP_TRANSACTION;
}
OCStackApplicationResult ProvisionEnrolleeResponse(void* /*ctx*/, OCDoHandle /*handle*/,
OCClientResponse *clientResponse)
{
OIC_LOG_V(DEBUG, ES_WIFI_PROV_TAG, "Inside ProvisionEnrolleeResponse");
// If user stopped the process then return from this function;
if (IsSetupStopped())
{
ErrorCallback(DEVICE_NOT_PROVISIONED);
ClearMemory();
return OC_STACK_DELETE_TRANSACTION;
}
if (!ValidateEnrolleeResponse(clientResponse))
{
ErrorCallback(DEVICE_NOT_PROVISIONED);
return OC_STACK_DELETE_TRANSACTION;
}
char query[OIC_STRING_MAX_VALUE] =
{ '\0' };
char resUri[MAX_URI_LENGTH] =
{ '\0' };
OIC_LOG_V(DEBUG, ES_WIFI_PROV_TAG, "Resource URI = %s", clientResponse->resourceUri);
OICStrcpy(resUri, sizeof(resUri), clientResponse->resourceUri);
#ifdef REMOTE_ARDUINO_ENROLEE
//Arduino Enrollee needs mediator application provide IP and port55555 which is specific
// to Arduino WiFi enrollee
// REMOTE_ARDUINO_ENROLEE has to be defined if Mediator is being tested with Arduino
snprintf(query, sizeof(query), UNICAST_PROV_STATUS_QUERY, clientResponse->addr->addr, IP_PORT,
resUri);
#else
snprintf(query, sizeof(query), UNICAST_PROV_STATUS_QUERY, clientResponse->addr->addr,
clientResponse->addr->port, resUri);
#endif
if (TriggerNetworkConnection(OC_HIGH_QOS, query, OC_RSRVD_ES_URI_PROV, clientResponse->addr, 0)
!= OC_STACK_OK)
{
OIC_LOG(INFO, ES_WIFI_PROV_TAG, "GetProvisioningStatusResponse received NULL clientResponse");
ErrorCallback(DEVICE_NOT_PROVISIONED);
ClearMemory();
}
return OC_STACK_DELETE_TRANSACTION;
}
OCStackApplicationResult GetProvisioningStatusResponse(void* /*ctx*/,
OCDoHandle /*handle*/,
OCClientResponse *clientResponse) {
// If user stopped the process then return from this function;
if (IsSetupStopped()) {
ErrorCallback(DEVICE_NOT_PROVISIONED);
ClearMemory();
return OC_STACK_DELETE_TRANSACTION;
}
if (!ValidateEnrolleResponse(clientResponse)) {
ErrorCallback(DEVICE_NOT_PROVISIONED);
ClearMemory();
return OC_STACK_DELETE_TRANSACTION;
}
OCRepPayload *input = (OCRepPayload * )(clientResponse->payload);
char query[OIC_STRING_MAX_VALUE] =
{'\0'};
char resURI[MAX_URI_LENGTH] =
{'\0'};
OIC_LOG_V(DEBUG, ES_WIFI_PROV_TAG, "resUri = %s", input->uri);
strncpy(resURI, input->uri, sizeof(resURI) - 1);
snprintf(query, sizeof(query), UNICAST_PROV_STATUS_QUERY, clientResponse->addr->addr, IP_PORT,
resURI);
if (ProvisionEnrollee(OC_HIGH_QOS, query, OC_RSRVD_ES_URI_PROV, clientResponse->addr, 0)
!= OC_STACK_OK) {
OIC_LOG(INFO, ES_WIFI_PROV_TAG, "GetProvisioningStatusResponse received NULL clientResponse");
ErrorCallback(DEVICE_NOT_PROVISIONED);
ClearMemory();
return OC_STACK_DELETE_TRANSACTION;
}
return OC_STACK_KEEP_TRANSACTION;
}
// This is a function called back when a device is discovered
OCStackApplicationResult FindProvisioningResourceResponse(void* /*ctx*/,
OCDoHandle /*handle*/,
OCClientResponse *clientResponse) {
OIC_LOG(INFO, ES_WIFI_PROV_TAG, PCF("Entering FindProvisioningResourceResponse"));
// If user stopped the process then return from this function;
if (IsSetupStopped()) {
ErrorCallback(DEVICE_NOT_PROVISIONED);
ClearMemory();
return OC_STACK_DELETE_TRANSACTION;
}
if (!ValidateFinddResourceResponse(clientResponse)) {
ErrorCallback(DEVICE_NOT_PROVISIONED);
return OC_STACK_DELETE_TRANSACTION;
}
char szQueryUri[64] = {0};
OCDiscoveryPayload *discoveryPayload = (OCDiscoveryPayload * )(clientResponse->payload);
OIC_LOG_V(DEBUG, ES_WIFI_PROV_TAG, "resUri = %s", discoveryPayload->resources->uri);
snprintf(szQueryUri, sizeof(szQueryUri), UNICAST_PROV_STATUS_QUERY,
clientResponse->devAddr.addr, IP_PORT, discoveryPayload->resources->uri);
OIC_LOG_V(DEBUG, ES_WIFI_PROV_TAG, "query before GetProvisioningStatus call = %s", szQueryUri);
if (GetProvisioningStatus(OC_HIGH_QOS, szQueryUri, &clientResponse->devAddr) != OC_STACK_OK) {
ErrorCallback(DEVICE_NOT_PROVISIONED);
return OC_STACK_DELETE_TRANSACTION;
}
return OC_STACK_KEEP_TRANSACTION;
}
OCStackResult StartProvisioningProcess(const EnrolleeNWProvInfo_t *netInfo,
OCProvisioningStatusCB provisioningStatusCallback,
char *findResQuery) {
if(findResQuery != NULL)
{
OICStrcpy(szFindResourceQueryUri, sizeof(szFindResourceQueryUri) - 1, findResQuery);
}
else
{
OIC_LOG(ERROR, ES_PROV_TAG, PCF("Find resource query is NULL"));
goto Error;
}
pthread_t thread_handle;
if (!ValidateEasySetupParams(netInfo, provisioningStatusCallback)) {
goto Error;
}
if (!SetProgress(provisioningStatusCallback)) {
// Device provisioning session is running already.
OIC_LOG(INFO, ES_PROV_TAG, PCF("Device provisioning session is running already"));
goto Error;
}
if (!ConfigEnrolleeObject(netInfo)) {
goto Error;
}
if (pthread_create(&thread_handle, NULL, FindProvisioningResource, NULL)) {
goto Error;
}
pthread_join(thread_handle, NULL);
return OC_STACK_OK;
Error:
{
ErrorCallback(DEVICE_NOT_PROVISIONED);
ClearMemory();
return OC_STACK_ERROR;
}
}
void SessionManager::AddSession(TcpSession* session)
{
if (NULL == session)
return;
session->SetCB(ReceiveCallback(this, &SessionManager::OnSessionReceive), ErrorCallback(this, &SessionManager::OnSessionError));
int handle = session->GetFD();
SessionInfo& info = m_Sessions.Get(handle);
if (!info.IsValid()){
SessionInfo sessionInfo;
sessionInfo.m_Handle = handle;
sessionInfo.m_Session = session;
m_Sessions.Add(handle, sessionInfo);
} else {
info.m_Handle = handle;
info.m_Session = session;
}
}
/*
**++
** FUNCTIONAL DESCRIPTION:
**
** COND_PushCondition
** This routine is used to log a condition on the stack. The user
** passes an error code (currently uninterpreted), a format string
** and optional format arguments. We use the vsprintf routine to
** interpret the user's format string and arguments, and we place the
** error condition and resultant string on the stack.
**
** FORMAL PARAMETERS:
**
** code:
** The condition code of the error/warning.
**
** controlString:
** format string for vsprintf statement
**
** [varargs]:
** variable arguments to be used with controlString
**
** RETURN VALUE:
**
** code (as passed in by the user)
**
** SIDE EFFECTS:
**
** Places a new entry on the stack. If the stack
** fills up, drop the last condition.
** Calls a user-established callback just before return.
**
*/
CONDITION
COND_PushCondition(CONDITION cond, char *controlString,...)
{
va_list args;
char buffer[1024];
/*lint -e40 -e50 */
va_start(args, controlString);
if (controlString == NULL) controlString = "NULL Control string passedto PushCondition";
(void) vsprintf(buffer, controlString, args);
va_end(args);
/*lint +e40 +e50 */
#ifdef CTN_USE_THREADS
if (THR_ObtainMutex(FAC_COND) != THR_NORMAL) {
fprintf(stderr, "COND_PushCondition unable to obtain mutex\n");
return cond;
}
#endif
stackPtr++;
EDBStack[stackPtr].statusCode = cond;
buffer[256] = '\0';
(void) strcpy(EDBStack[stackPtr].statusText, buffer);
if (ErrorCallback != NULL) ErrorCallback(EDBStack[stackPtr].statusCode, EDBStack[stackPtr].statusText);
if (stackPtr >= MAXEDB - 2) {
dumpstack(stderr);
fprintf(stderr, "CONDITION Stack overflow\n");
stackPtr = 0;
}
#ifdef CTN_USE_THREADS
if (THR_ReleaseMutex(FAC_COND) != THR_NORMAL) {
fprintf(stderr, "COND_PushCondition unable to release mutex, exiting\n");
exit(1);
}
#endif
return cond;
}
IpAddress
syncResolve(const std::string& host, boost::asio::io_service& ioService,
const ndn::dns::AddressSelector& addressSelector)
{
Resolver resolver(SuccessCallback(), ErrorCallback(), addressSelector, ioService);
BoostResolver::query query(host, Resolver::NULL_PORT);
BoostResolver::iterator remoteEndpoint = resolver.syncResolve(query);
BoostResolver::iterator end;
for (; remoteEndpoint != end; ++remoteEndpoint)
{
if (addressSelector(EndPoint(*remoteEndpoint).address()))
{
return EndPoint(*remoteEndpoint).address();
}
}
BOOST_THROW_EXCEPTION(Error("No endpoint matching the specified address selector found"));
}
IpAddress
syncResolve(const std::string& host, boost::asio::io_service& ioService,
const ndn::dns::AddressSelector& addressSelector)
{
Resolver resolver(SuccessCallback(), ErrorCallback(), addressSelector, ioService);
BoostResolver::query query(host, Resolver::NULL_PORT
#if not defined(__FreeBSD__)
, BoostResolver::query::all_matching
#endif
);
BoostResolver::iterator remoteEndpoint = resolver.syncResolve(query);
BoostResolver::iterator end;
for (; remoteEndpoint != end; ++remoteEndpoint)
{
if (addressSelector(EndPoint(*remoteEndpoint).address()))
{
return EndPoint(*remoteEndpoint).address();
}
}
throw Error("No endpoint matching the specified address selector found");
}
OCStackApplicationResult ProvisionEnrolleeResponse(void *ctx, OCDoHandle handle,
OCClientResponse *clientResponse) {
OIC_LOG_V(DEBUG, TAG, "INSIDE ProvisionEnrolleeResponse");
// If user stopped the process then return from this function;
if (IsSetupStopped()) {
ErrorCallback(DEVICE_NOT_PROVISIONED);
ClearMemory();
return OC_STACK_DELETE_TRANSACTION;
}
ProvisioningInfo *provInfo;
if (!ValidateEnrolleResponse(clientResponse)) {
ErrorCallback(DEVICE_NOT_PROVISIONED);
return OC_STACK_DELETE_TRANSACTION;
}
char *tnn;
char *cd;
OCRepPayload *input = (OCRepPayload * )(clientResponse->payload);
while (input) {
int64_t ps;
if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_PS, &ps)) {
if (ps == 1) {
input = input->next;
continue;
}
else {
OIC_LOG_V(DEBUG, TAG, "PS is NOT proper");
goto Error;
}
}
if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_TNN, &tnn)) {
if (!strcmp(tnn, netProvInfo->netAddressInfo.WIFI.ssid)) {
OIC_LOG_V(DEBUG, TAG, "SSID is proper");
input = input->next;
continue;
}
else {
OIC_LOG_V(DEBUG, TAG, "SSID is NOT proper");
goto Error;
}
}
if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_CD, &cd)) {
if (!strcmp(cd, netProvInfo->netAddressInfo.WIFI.pwd)) {
OIC_LOG_V(DEBUG, TAG, "Password is proper");
input = input->next;
continue;
}
else {
OIC_LOG_V(DEBUG, TAG, "Password is NOT proper");
goto Error;
}
}
LogProvisioningResponse(input->values);
input = input->next;
}
SuccessCallback(clientResponse);
return OC_STACK_KEEP_TRANSACTION;
Error:
{
ErrorCallback(DEVICE_NOT_PROVISIONED);
return OC_STACK_DELETE_TRANSACTION;
}
}
OCStackApplicationResult GetProvisioningStatusResponse(void* /*ctx*/, OCDoHandle /*handle*/,
OCClientResponse *clientResponse)
{
// If user stopped the process then return from this function;
if (IsSetupStopped())
{
ErrorCallback(DEVICE_NOT_PROVISIONED);
ClearMemory();
return OC_STACK_DELETE_TRANSACTION;
}
if (!ValidateEnrolleeResponse(clientResponse))
{
ErrorCallback(DEVICE_NOT_PROVISIONED);
ClearMemory();
return OC_STACK_DELETE_TRANSACTION;
}
OCRepPayload *input = (OCRepPayload *) (clientResponse->payload);
char resUri[MAX_URI_LENGTH] = { '\0' };
OIC_LOG_V(DEBUG, ES_WIFI_PROV_TAG, "resUri = %s", clientResponse->resourceUri);
OICStrcpy(resUri, sizeof(resUri), clientResponse->resourceUri);
while (input)
{
int64_t ps;
if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_PS, &ps))
{
if (ps == ES_PS_NEED_PROVISIONING)
{
input = input->next;
continue;
}
else
{
ErrorCallback(DEVICE_NOT_PROVISIONED);
ClearMemory();
return OC_STACK_DELETE_TRANSACTION;
}
}
LogProvisioningResponse(input->values);
input = input->next;
}
char query[OIC_STRING_MAX_VALUE] =
{ '\0' };
#ifdef REMOTE_ARDUINO_ENROLEE
//Arduino Enrollee needs mediator application provide IP and port55555 which is specific
// to Arduino WiFi enrollee
// REMOTE_ARDUINO_ENROLEE has to be defined if Mediator is being tested with Arduino
snprintf(query, sizeof(query), UNICAST_PROV_STATUS_QUERY, clientResponse->addr->addr, IP_PORT,
resUri);
#else
snprintf(query, sizeof(query), UNICAST_PROV_STATUS_QUERY, clientResponse->addr->addr,
clientResponse->addr->port, resUri);
#endif
if (ProvisionEnrollee(OC_HIGH_QOS, query, OC_RSRVD_ES_URI_PROV, clientResponse->addr, 0)
!= OC_STACK_OK)
{
OIC_LOG(INFO, ES_WIFI_PROV_TAG, "GetProvisioningStatusResponse received NULL clientResponse");
ErrorCallback(DEVICE_NOT_PROVISIONED);
ClearMemory();
return OC_STACK_DELETE_TRANSACTION;
}
return OC_STACK_KEEP_TRANSACTION;
}
