int
main(int argc, char** argv) {
uint8_t addr[20] = {0};
uint8_t* paddr = NULL;
uint16_t port = OC_WELL_KNOWN_PORT;
uint8_t ifname[] = "wlan0";
pthread_t threadId;
pthread_t threadId_presence;
int opt;
printf ("OCServer is starting...\n");
if (OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr,
sizeof(addr)) == ERR_SUCCESS) {
printf ("Starting ocserver on address %s:%d\n",addr,port);
paddr = addr;
}
/*
* Init IoTivity as a SERVER.
*/
if (OCInit((char *) paddr, port, OC_SERVER) != OC_STACK_OK) {
printf ("OCStack init error\n");
return 0;
}
OCSetDefaultDeviceEntityHandler(OCDeviceEntityHandlerCb);
OCStackResult deviceResult = SetDeviceInfo(contentType, dateOfManufacture, deviceName,
deviceUUID, firmwareVersion, hostName, manufacturerName,
manufacturerUrl, modelNumber, platformVersion, supportUrl, version);
deviceResult = OCSetDeviceInfo(deviceInfo);
if (deviceResult != OC_STACK_OK) {
printf ("Device Registration failed!\n");
exit (EXIT_FAILURE);
}
DeleteDeviceInfo();
/*
* Create ONE light resource.
*/
createLightResource(gResourceUri, &Light);
printf ("Entering ocserver main loop...\n");
signal(SIGINT, handleSigInt);
while (!gQuitFlag) {
/*
* Main IoTivity function for processing.
*/
if (OCProcess() != OC_STACK_OK) {
printf ("OCStack process error\n");
return 0;
}
sleep(2);
}
if (OCStop() != OC_STACK_OK) {
printf ("OCStack process error\n");
}
return 0;
}
OCStackResult FindNetworkResource() {
OCStackResult ret = OC_STACK_ERROR;
if (OCStop() != OC_STACK_OK) {
OIC_LOG(ERROR, TAG, "OCStack stop error");
}
return ret;
}
InProcServerWrapper::~InProcServerWrapper()
{
if(m_processThread.joinable())
{
m_threadRun = false;
m_processThread.join();
}
OCStop();
}
int main()
{
struct timespec timeout;
OIC_LOG(DEBUG, TAG, "OCServer is starting...");
// Set callbacks for verification
SetDisplayNumCB(NULL, displayNumCB);
SetUserConfirmCB(NULL, confirmNumCB);
// Set Verification Option for ownership transfer
// Currently, BOTH display AND confirm
SetVerifyOption((VerifyOptionBitmask_t)(DISPLAY_NUM | USER_CONFIRM));
// Initialize Persistent Storage for SVR database
OCPersistentStorage ps = {server_fopen, fread, fwrite, fclose, unlink};
OCRegisterPersistentStorageHandler(&ps);
if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
/*
* Declare and create the example resource: LED
*/
createLEDResource(gResourceUri, &LED, false, 0);
timeout.tv_sec = 0;
timeout.tv_nsec = 100000000L;
// Break from loop with Ctrl-C
OIC_LOG(INFO, TAG, "Entering ocserver main loop...");
signal(SIGINT, handleSigInt);
while (!gQuitFlag)
{
if (OCProcess() != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
nanosleep(&timeout, NULL);
}
OIC_LOG(INFO, TAG, "Exiting ocserver main loop...");
if (OCStop() != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack process error");
}
return 0;
}
int main(void)
{
struct timespec timeout;
// Initialize Persistent Storage for SVR database
OCPersistentStorage ps = { client_fopen, fread, fwrite, fclose, unlink };
OCRegisterPersistentStorageHandler(&ps);
/* Initialize OCStack*/
if (OCInit(NULL, 0, OC_CLIENT_SERVER) != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
// DeviceDiscovery();
timeout.tv_sec = 0;
timeout.tv_nsec = 100000000L;
// Break from loop with Ctrl+C
OIC_LOG(INFO, TAG, "Entering occlient main loop...");
signal(SIGINT, handleSigInt);
// CLI
int thr_id;
pthread_t p_thread;
thr_id = pthread_create(&p_thread, NULL, CLInterface, (void *)NULL);
if (thr_id < 0)
{
OIC_LOG(ERROR, TAG, "create CLI Thread error");
return 0;
}
// loop
while (!gQuitFlag)
{
if (OCProcess() != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
nanosleep(&timeout, NULL);
}
OIC_LOG(INFO, TAG, "Exiting occlient main loop...");
if (OCStop() != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack stop error");
}
return 0;
}
OCStackResult TerminateProvisioningHandler() {
OCStackResult ret = OC_STACK_ERROR;
if (OCStop() != OC_STACK_OK) {
OIC_LOG(ERROR, TAG, "OCStack stop error");
}
g_provisioningCondFlag = true;
ret = OC_STACK_OK;
return ret;
}
int main()
{
struct timespec timeout;
OIC_LOG(DEBUG, TAG, "OCServer is starting...");
// Initialize Persistent Storage for SVR database
OCPersistentStorage ps = {server_fopen, fread, fwrite, fclose, unlink};
OCRegisterPersistentStorageHandler(&ps);
if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
/**
* If server supported random pin based ownership transfer,
* callback of print PIN should be registered before runing server.
*/
SetGeneratePinCB(&GeneratePinCB);
/*
* Declare and create the example resource: LED
*/
createLEDResource(gResourceUri, &LED, false, 0);
timeout.tv_sec = 0;
timeout.tv_nsec = 100000000L;
// Break from loop with Ctrl-C
OIC_LOG(INFO, TAG, "Entering ocserver main loop...");
signal(SIGINT, handleSigInt);
while (!gQuitFlag)
{
if (OCProcess() != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
nanosleep(&timeout, NULL);
}
OIC_LOG(INFO, TAG, "Exiting ocserver main loop...");
if (OCStop() != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack process error");
}
return 0;
}
int main(int argc, char* argv[])
{
struct timespec timeout;
OC_LOG(DEBUG, TAG, "OCServer is starting...");
// Initialize Persistent Storage for SVR database
OCPersistentStorage ps = {};
ps.open = server_fopen;
ps.read = fread;
ps.write = fwrite;
ps.close = fclose;
ps.unlink = unlink;
OCRegisterPersistentStorageHandler(&ps);
if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
/*
* Declare and create the example resource: LED
*/
createLEDResource(gResourceUri, &LED, false, 0);
timeout.tv_sec = 0;
timeout.tv_nsec = 100000000L;
// Break from loop with Ctrl-C
OC_LOG(INFO, TAG, "Entering ocserver main loop...");
signal(SIGINT, handleSigInt);
while (!gQuitFlag)
{
if (OCProcess() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
nanosleep(&timeout, NULL);
}
OC_LOG(INFO, TAG, "Exiting ocserver main loop...");
if (OCStop() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack process error");
}
return 0;
}
int main(int argc, char* argv[])
{
OC_LOG(DEBUG, TAG, "OCServer is starting...");
if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
// Declare and create the example resource: LED
createLEDResource(gResourceUri, &LED, false, 42);
// Initialize slow response alarm
signal(SIGALRM, AlarmHandler);
// Break from loop with Ctrl-C
OC_LOG(INFO, TAG, "Entering ocserver main loop...");
signal(SIGINT, handleSigInt);
while (!gQuitFlag)
{
if (OCProcess() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
sleep(2);
}
OC_LOG(INFO, TAG, "Exiting ocserver main loop...");
// Free requests
if (!gRequestList.empty())
{
for (auto iter = gRequestList.begin(); iter != gRequestList.end(); ++iter)
{
OICFree((*iter)->query);
OCPayloadDestroy((*iter)->payload);
OICFree(*iter);
}
gRequestList.clear();
}
if (OCStop() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack process error");
}
return 0;
}
InProcClientWrapper::~InProcClientWrapper()
{
if(m_threadRun && m_listeningThread.joinable())
{
m_threadRun = false;
m_listeningThread.join();
}
// only stop if we are the ones who actually called 'init'. We are counting
// on the server to do the stop.
if(m_cfg.mode == ModeType::Client)
{
OCStop();
}
}
int main()
{
OIC_LOG(DEBUG, TAG, "OCServer is starting...");
SetPersistentHandler(&ps);
if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
/*
* Declare and create the example resource: Light
*/
createLightResource(gResourceUri, &Light);
CASelectCipherSuite(TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8);
struct timespec timeout;
timeout.tv_sec = 0;
timeout.tv_nsec = 100000000L;
// Break from loop with Ctrl-C
OIC_LOG(INFO, TAG, "Entering ocserver main loop...");
signal(SIGINT, handleSigInt);
while (!gQuitFlag)
{
if (OCProcess() != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
nanosleep(&timeout, NULL);
}
OIC_LOG(INFO, TAG, "Exiting ocserver main loop...");
if (OCStop() != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack process error");
}
return 0;
}
OCStackResult InProcServerWrapper::stop()
{
OIC_LOG(INFO, TAG, "stop");
if(m_processThread.joinable())
{
m_threadRun = false;
m_processThread.join();
}
OCStackResult res = OCStop();
if (OC_STACK_OK != res)
{
throw InitializeException(OC::InitException::STACK_TERMINATE_ERROR, res);
}
return OC_STACK_OK;
}
int main() {
OIC_LOG_V(INFO, TAG, "Starting occlient on address %s",addr);
/* Initialize OCStack*/
if (OCInit(NULL, 0, OC_CLIENT) != OC_STACK_OK) {
OIC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
/* Start a discovery query*/
char szQueryUri[64] = { 0 };
strcpy(szQueryUri, OC_EXPLICIT_DEVICE_DISCOVERY_URI);
if (OCDoResource(NULL, OC_REST_GET, szQueryUri, 0, 0, OC_LOW_QOS,
0, 0, 0) != OC_STACK_OK) {
OIC_LOG(ERROR, TAG, "OCStack resource error");
return 0;
}
// Break from loop with Ctrl+C
OIC_LOG(INFO, TAG, "Entering occlient main loop...");
signal(SIGINT, handleSigInt);
while (!gQuitFlag) {
if (OCProcess() != OC_STACK_OK) {
OIC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
sleep(1);
}
OIC_LOG(INFO, TAG, "Exiting occlient main loop...");
if (OCStop() != OC_STACK_OK) {
OIC_LOG(ERROR, TAG, "OCStack stop error");
}
return 0;
}
void deinit_builder(things_server_builder_s *builder)
{
if (builder != NULL) {
g_quit_flag = 1;
pthread_cancel(g_thread_id_server);
pthread_join(g_thread_id_server, NULL);
pthread_detach(g_thread_id_server);
g_thread_id_server = NULL;
// 1. Need to unregister those registered resource in the Stack
// 2. Free the payload of each resources
for (size_t iter = 0; iter < builder->res_num; iter++) {
if (builder->gres_arr[iter]->rep != NULL) {
things_release_representation_inst(builder->gres_arr[iter]->rep);
}
}
}
if (OCStop() != OC_STACK_OK) {
THINGS_LOG_E(TAG, "OCStack process error");
}
}
int
main(int argc, char** argv) {
uint8_t addr[20] = {0};
uint8_t* paddr = NULL;
uint16_t port = USE_RANDOM_PORT;
uint8_t ifname[] = "wlan0";
int opt;
printf ("OCClient is starting...\n");
if (OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr,
sizeof(addr)) == ERR_SUCCESS) {
printf ("Starting occlient on address %s\n",addr);
paddr = addr;
}
if (OCInit((char *) paddr, port, OC_CLIENT) != OC_STACK_OK) {
printf ("OCStack init error\n");
return 0;
}
InitDiscovery ();
signal(SIGINT, handleSigInt);
while (!gQuitFlag) {
if (OCProcess() != OC_STACK_OK) {
printf ("OCStack process error\n");
return 0;
}
sleep(2);
}
if (OCStop() != OC_STACK_OK) {
printf ("OCStack process error\n");
}
return 0;
}
int main(int /*argc*/, char* /*argv*/[])
{
OC_LOG(DEBUG, TAG, "OCServer is starting...");
if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
/*
* Declare and create the example resource: LED
*/
createLEDResource(gResourceUri, &LED, false, 0);
// Break from loop with Ctrl-C
OC_LOG(INFO, TAG, "Entering ocserver main loop...");
signal(SIGINT, handleSigInt);
while (!gQuitFlag)
{
if (OCProcess() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
sleep(2);
}
OC_LOG(INFO, TAG, "Exiting ocserver main loop...");
if (OCStop() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack process error");
}
return 0;
}
int main() {
OIC_LOG_V(INFO, TAG, "Starting ocserver");
if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK) {
OIC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
/*
* Declare and create the example resource: Light
*/
if(createLightResource() != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack cannot create resource...");
}
// Break from loop with Ctrl-C
OIC_LOG(INFO, TAG, "Entering ocserver main loop...");
signal(SIGINT, handleSigInt);
while (!gQuitFlag) {
if (OCProcess() != OC_STACK_OK) {
OIC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
sleep(1);
}
OIC_LOG(INFO, TAG, "Exiting ocserver main loop...");
if (OCStop() != OC_STACK_OK) {
OIC_LOG(ERROR, TAG, "OCStack process error");
}
return 0;
}
int main(int argc, char* argv[])
{
uint8_t addr[20] = {0};
uint8_t* paddr = NULL;
uint16_t port = OC_WELL_KNOWN_PORT;
uint8_t ifname[] = "eth0";
pthread_t threadId;
pthread_t threadId_presence;
int opt;
while ((opt = getopt(argc, argv, "o:")) != -1)
{
switch(opt)
{
case 'o':
gObserveNotifyType = atoi(optarg);
break;
default:
PrintUsage();
return -1;
}
}
if ((gObserveNotifyType != 0) && (gObserveNotifyType != 1))
{
PrintUsage();
return -1;
}
OC_LOG(DEBUG, TAG, "OCServer is starting...");
/*Get Ip address on defined interface and initialize coap on it with random port number
* this port number will be used as a source port in all coap communications*/
if ( OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr,
sizeof(addr)) == ERR_SUCCESS)
{
OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
paddr = addr;
}
if (OCInit((char *) paddr, port, OC_SERVER) != OC_STACK_OK) {
OC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
#ifdef WITH_PRESENCE
if (OCStartPresence(0) != OC_STACK_OK) {
OC_LOG(ERROR, TAG, "OCStack presence/discovery error");
return 0;
}
#endif
OCSetDefaultDeviceEntityHandler(OCDeviceEntityHandlerCb);
OCStackResult deviceResult = SetDeviceInfo(contentType, dateOfManufacture, deviceName,
deviceUUID, firmwareVersion, hostName, manufacturerName,
manufacturerUrl, modelNumber, platformVersion, supportUrl, version);
if (deviceResult != OC_STACK_OK)
{
OC_LOG(INFO, TAG, "Device Registration failed!");
exit (EXIT_FAILURE);
}
deviceResult = OCSetDeviceInfo(deviceInfo);
if (deviceResult != OC_STACK_OK)
{
OC_LOG(INFO, TAG, "Device Registration failed!");
exit (EXIT_FAILURE);
}
/*
* Declare and create the example resource: Light
*/
createLightResource(gResourceUri, &Light);
// Initialize observations data structure for the resource
for (uint8_t i = 0; i < SAMPLE_MAX_NUM_OBSERVATIONS; i++)
{
interestedObservers[i].valid = false;
}
/*
* Create a thread for changing the representation of the Light
*/
pthread_create (&threadId, NULL, ChangeLightRepresentation, (void *)NULL);
/*
* Create a thread for generating changes that cause presence notifications
* to be sent to clients
*/
pthread_create(&threadId_presence, NULL, presenceNotificationGenerator, (void *)NULL);
// Break from loop with Ctrl-C
OC_LOG(INFO, TAG, "Entering ocserver main loop...");
DeleteDeviceInfo();
signal(SIGINT, handleSigInt);
while (!gQuitFlag) {
if (OCProcess() != OC_STACK_OK) {
OC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
sleep(2);
}
/*
* Cancel the Light thread and wait for it to terminate
*/
pthread_cancel(threadId);
pthread_join(threadId, NULL);
pthread_cancel(threadId_presence);
pthread_join(threadId_presence, NULL);
OC_LOG(INFO, TAG, "Exiting ocserver main loop...");
if (OCStop() != OC_STACK_OK) {
OC_LOG(ERROR, TAG, "OCStack process error");
}
return 0;
}
int main(int argc, char* argv[])
{
int opt;
resourceList = NULL;
while ((opt = getopt(argc, argv, "u:t:c:")) != -1)
{
switch(opt)
{
case 'u':
UNICAST_DISCOVERY = atoi(optarg);
break;
case 't':
TEST_CASE = atoi(optarg);
break;
case 'c':
// TODO: re-enable IPv4/IPv6 command line selection when IPv6 is supported
// OC_CONNTYPE = OCConnectivityType(atoi(optarg));
OC_CONNTYPE = OC_IPV4;
OC_LOG(INFO, TAG, "Using default IPv4, IPv6 not currently supported.");
break;
default:
PrintUsage();
return -1;
}
}
if ((UNICAST_DISCOVERY != 0 && UNICAST_DISCOVERY != 1) ||
(TEST_CASE < TEST_DISCOVER_REQ || TEST_CASE >= MAX_TESTS) )
{
PrintUsage();
return -1;
}
/* Initialize OCStack*/
if (OCInit(NULL, 0, OC_CLIENT) != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
InitDiscovery();
// Break from loop with Ctrl+C
signal(SIGINT, handleSigInt);
while (!gQuitFlag)
{
if (OCProcess() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
sleep(2);
}
freeResourceList();
OC_LOG(INFO, TAG, "Exiting occlient main loop...");
if (OCStop() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack stop error");
}
return 0;
}
int main(int argc, char* argv[])
{
uint8_t addr[20] = {0};
uint8_t* paddr = NULL;
uint16_t port = 0;
uint8_t ifname[] = "eth0";
pthread_t threadId;
int opt;
while ((opt = getopt(argc, argv, "t:")) != -1)
{
switch(opt)
{
case 't':
TEST = atoi(optarg);
break;
default:
PrintUsage();
return -1;
}
}
if(TEST <= TEST_INVALID || TEST >= MAX_TESTS){
PrintUsage();
return -1;
}
OC_LOG(DEBUG, TAG, "OCServer is starting...");
/*Get Ip address on defined interface and initialize coap on it with random port number
* this port number will be used as a source port in all coap communications*/
if (OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr,
sizeof(addr)) == ERR_SUCCESS)
{
OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
paddr = addr;
}
if (OCInit((char *) paddr, port, OC_SERVER) != OC_STACK_OK) {
OC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
/*
* Declare and create the example resource: light
*/
createResources();
/*
* Create a thread for changing the representation of the light
*/
pthread_create (&threadId, NULL, ChangeLightRepresentation, (void *)NULL);
// Break from loop with Ctrl-C
OC_LOG(INFO, TAG, "Entering ocserver main loop...");
signal(SIGINT, handleSigInt);
while (!gQuitFlag)
{
if (OCProcess() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
sleep(2);
}
/*
* Cancel the light thread and wait for it to terminate
*/
pthread_cancel(threadId);
pthread_join(threadId, NULL);
OC_LOG(INFO, TAG, "Exiting ocserver main loop...");
if (OCStop() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack process error");
}
return 0;
}
int main(int argc, char* argv[])
{
int opt;
while ((opt = getopt(argc, argv, "t:c:")) != -1)
{
switch (opt)
{
case 't':
TestType = atoi(optarg);
break;
case 'c':
ConnectivityType = atoi(optarg);
break;
default:
PrintUsage();
return -1;
}
}
if ((TestType <= TEST_INVALID || TestType >= MAX_TESTS) ||
ConnectivityType >= MAX_CT)
{
PrintUsage();
return -1;
}
/* Initialize OCStack*/
if (OCInit(NULL, 0, OC_CLIENT) != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
if(ConnectivityType == CT_ADAPTER_DEFAULT || ConnectivityType == CT_IP)
{
ConnType = CT_ADAPTER_IP;
}
else
{
OIC_LOG(INFO, TAG, "Default Connectivity type selected...");
ConnType = CT_ADAPTER_IP;
}
InitDiscovery();
// Break from loop with Ctrl+C
OIC_LOG(INFO, TAG, "Entering occlient main loop...");
signal(SIGINT, handleSigInt);
while (!gQuitFlag)
{
if (OCProcess() != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
sleep(2);
} OIC_LOG(INFO, TAG, "Exiting occlient main loop...");
if (OCStop() != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack stop error");
}
return 0;
}
int main(int argc, char* argv[])
{
uint8_t addr[20] = {0};
uint8_t* paddr = NULL;
uint16_t port = USE_RANDOM_PORT;
uint8_t ifname[] = "eth0";
int opt;
while ((opt = getopt(argc, argv, "u:t:")) != -1)
{
switch(opt)
{
case 'u':
UNICAST_DISCOVERY = atoi(optarg);
break;
case 't':
TEST_CASE = atoi(optarg);
break;
default:
PrintUsage();
return -1;
}
}
if ((UNICAST_DISCOVERY != 0 && UNICAST_DISCOVERY != 1) ||
(TEST_CASE < TEST_DISCOVER_REQ || TEST_CASE >= MAX_TESTS) )
{
PrintUsage();
return -1;
}
/*Get Ip address on defined interface and initialize coap on it with random port number
* this port number will be used as a source port in all coap communications*/
if ( OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr,
sizeof(addr)) == ERR_SUCCESS)
{
OC_LOG_V(INFO, TAG, "Starting occlient on address %s",addr);
paddr = addr;
}
/* Initialize OCStack*/
if (OCInit((char *) paddr, port, OC_CLIENT) != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
InitDiscovery();
// Break from loop with Ctrl+C
OC_LOG(INFO, TAG, "Entering occlient main loop...");
signal(SIGINT, handleSigInt);
while (!gQuitFlag)
{
if (OCProcess() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
sleep(2);
}
OC_LOG(INFO, TAG, "Exiting occlient main loop...");
if (OCStop() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack stop error");
}
return 0;
}
int main(int argc, char* argv[])
{
int opt;
while ((opt = getopt(argc, argv, "u:t:c:")) != -1)
{
switch(opt)
{
case 'u':
UnicastDiscovery = atoi(optarg);
break;
case 't':
TestCase = atoi(optarg);
break;
case 'c':
Connectivity = atoi(optarg);
break;
default:
PrintUsage();
return -1;
}
}
if ((UnicastDiscovery != 0 && UnicastDiscovery != 1) ||
(TestCase < TEST_DISCOVER_REQ || TestCase >= MAX_TESTS) ||
(Connectivity < CT_ADAPTER_DEFAULT || Connectivity >= MAX_CT))
{
PrintUsage();
return -1;
}
if (OCInit1(OC_CLIENT, OC_DEFAULT_FLAGS, OC_DEFAULT_FLAGS) != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
#ifdef ROUTING_GATEWAY
/*
* Before invoking Discover resource, we process the gateway requests
* and form the routing table.
*/
for (int index = 0; index < MAX_NUM_GATEWAY_REQUEST; index++)
{
if (OC_STACK_OK != OCProcess())
{
OIC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
usleep(SLEEP_DURATION);
}
#endif
if (Connectivity == CT_ADAPTER_DEFAULT || Connectivity == CT_IP)
{
ConnType = CT_ADAPTER_IP;
}
else
{
OIC_LOG(INFO, TAG, "Default Connectivity type selected...");
PrintUsage();
}
discoveryAddr[0] = '\0';
if (UnicastDiscovery)
{
OIC_LOG(INFO, TAG, "Enter IP address of server with optional port number");
OIC_LOG(INFO, TAG, "IPv4: 192.168.0.15:45454\n");
OIC_LOG(INFO, TAG, "IPv6: [fe80::20c:29ff:fe1b:9c5]:45454\n");
if (fgets(discoveryAddr, sizeof (discoveryAddr), stdin))
{
//Strip newline char from ipv4addr
StripNewLineChar(discoveryAddr);
}
else
{
OIC_LOG(ERROR, TAG, "!! Bad input for IP address. !!");
return OC_STACK_INVALID_PARAM;
}
}
if (UnicastDiscovery == 0 && TestCase == TEST_DISCOVER_DEV_REQ)
{
InitDeviceDiscovery(OC_LOW_QOS);
}
else if (UnicastDiscovery == 0 && TestCase == TEST_DISCOVER_PLATFORM_REQ)
{
InitPlatformDiscovery(OC_LOW_QOS);
}
else
{
InitDiscovery(OC_LOW_QOS);
}
// Break from loop with Ctrl+C
OIC_LOG(INFO, TAG, "Entering occlient main loop...");
signal(SIGINT, handleSigInt);
while (!gQuitFlag)
{
if (OCProcess() != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
#ifndef ROUTING_GATEAWAY
sleep(1);
#endif
}
OIC_LOG(INFO, TAG, "Exiting occlient main loop...");
if (OCStop() != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack stop error");
}
return 0;
}
int main(int argc, char* argv[])
{
#ifdef RA_ADAPTER
char host[] = "localhost";
char user[] = "test1";
char pass[] = "intel123";
char empstr[] = "";
OCRAInfo_t rainfo = {};
rainfo.hostname = host;
rainfo.port = 5222;
rainfo.xmpp_domain = host;
rainfo.username = user;
rainfo.password = pass;
rainfo.resource = empstr;
rainfo.user_jid = empstr;
rainfo.jidbound = jidbound;
#endif
int opt = 0;
while ((opt = getopt(argc, argv, "o:s:p:d:u:w:r:j:")) != -1)
{
switch(opt)
{
case 'o':
gObserveNotifyType = atoi(optarg);
break;
#ifdef RA_ADAPTER
case 's':
rainfo.hostname = optarg;
break;
case 'p':
rainfo.port = atoi(optarg);
break;
case 'd':
rainfo.xmpp_domain = optarg;
break;
case 'u':
rainfo.username = optarg;
break;
case 'w':
rainfo.password = optarg;
break;
case 'j':
rainfo.user_jid = optarg;
break;
case 'r':
rainfo.resource = optarg;
break;
#endif
default:
PrintUsage();
return -1;
}
}
if ((gObserveNotifyType != 0) && (gObserveNotifyType != 1))
{
PrintUsage();
return -1;
}
#ifdef RA_ADAPTER
OCSetRAInfo(&rainfo);
#endif
OIC_LOG(DEBUG, TAG, "OCServer is starting...");
if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
#ifdef WITH_PRESENCE
if (OCStartPresence(0) != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack presence/discovery error");
return 0;
}
#endif
OCSetDefaultDeviceEntityHandler(OCDeviceEntityHandlerCb, NULL);
OCStackResult registrationResult =
SetPlatformInfo(platformID, manufacturerName, manufacturerUrl, modelNumber,
dateOfManufacture, platformVersion, operatingSystemVersion, hardwareVersion,
firmwareVersion, supportUrl, systemTime);
if (registrationResult != OC_STACK_OK)
{
OIC_LOG(INFO, TAG, "Platform info setting failed locally!");
exit (EXIT_FAILURE);
}
registrationResult = OCSetPlatformInfo(platformInfo);
if (registrationResult != OC_STACK_OK)
{
OIC_LOG(INFO, TAG, "Platform Registration failed!");
exit (EXIT_FAILURE);
}
registrationResult = SetDeviceInfo(deviceName, specVersion, dataModelVersions);
if (registrationResult != OC_STACK_OK)
{
OIC_LOG(INFO, TAG, "Device info setting failed locally!");
exit (EXIT_FAILURE);
}
OCResourcePayloadAddStringLL(&deviceInfo.types, "oic.d.tv");
registrationResult = OCSetDeviceInfo(deviceInfo);
if (registrationResult != OC_STACK_OK)
{
OIC_LOG(INFO, TAG, "Device Registration failed!");
exit (EXIT_FAILURE);
}
/*
* Declare and create the example resource: Light
*/
createLightResource(gResourceUri, &Light);
// Initialize observations data structure for the resource
for (uint8_t i = 0; i < SAMPLE_MAX_NUM_OBSERVATIONS; i++)
{
interestedObservers[i].valid = false;
}
/*
* Create a thread for generating changes that cause presence notifications
* to be sent to clients
*/
#ifdef WITH_PRESENCE
pthread_create(&threadId_presence, NULL, presenceNotificationGenerator, (void *)NULL);
#endif
// Break from loop with Ctrl-C
OIC_LOG(INFO, TAG, "Entering ocserver main loop...");
DeletePlatformInfo();
DeleteDeviceInfo();
signal(SIGINT, handleSigInt);
while (!gQuitFlag)
{
if (OCProcess() != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
}
if (observeThreadStarted)
{
pthread_cancel(threadId_observe);
pthread_join(threadId_observe, NULL);
}
pthread_cancel(threadId_presence);
pthread_join(threadId_presence, NULL);
OIC_LOG(INFO, TAG, "Exiting ocserver main loop...");
if (OCStop() != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack process error");
}
return 0;
}
int main()
{
OIC_LOG(INFO, TAG, "Initializing IoTivity...");
OCStackResult result = OCInit(NULL, 0, OC_SERVER);
if (result != OC_STACK_OK)
{
OIC_LOG_V(ERROR, TAG, "OCInit Failed %d", result);
return -1;
}
result = SetPlatformInfo();
if (result != OC_STACK_OK)
{
OIC_LOG_V(ERROR, TAG, "SetPlatformInfo Failed %d", result);
goto IotivityStop;
}
result = SetDeviceInfo();
if (result != OC_STACK_OK)
{
OIC_LOG_V(ERROR, TAG, "SetPlatformInfo Failed: %d", result);
goto IotivityStop;
}
result = OCStartPresence(0);
if (result != OC_STACK_OK)
{
OIC_LOG_V(ERROR, TAG, "OCStartPresence Failed: %d", result);
goto IotivityStop;
}
// PIStartPlugin
PIPlugin* plugin = NULL;
OIC_LOG(INFO, TAG, "IoTivity Initialized properly, Starting Zigbee Plugin...");
result = PIStartPlugin(defaultComPort, PLUGIN_ZIGBEE, &plugin);
if (result != OC_STACK_OK)
{
OIC_LOG_V(ERROR, TAG, "Zigbee Plugin Start Failed: %d", result);
goto IotivityStop;
}
if (signal(SIGINT, processCancel) == SIG_ERR)
{
OIC_LOG(ERROR, TAG, "Unable to catch SIGINT, terminating...");
}
else
{
OIC_LOG(INFO, TAG, "Zigbee Plugin started correctly, press Ctrl-C to terminate application");
// Loop until sigint
while (!processSignal(false) && result == OC_STACK_OK)
{
result = OCProcess();
if (result != OC_STACK_OK)
{
OIC_LOG_V(ERROR, TAG, "OCProcess Failed: %d", result);
break;
}
result = PIProcess(plugin);
if (result != OC_STACK_OK)
{
OIC_LOG_V(ERROR, TAG, "PIProcess Failed: %d", result);
}
}
}
OIC_LOG(INFO, TAG, "Stopping Zigbee Plugin...");
result = PIStopPlugin(plugin);
if (result != OC_STACK_OK)
{
OIC_LOG_V(ERROR, TAG, "Zigbee Plugin Stop Failed: %d", result);
}
OIC_LOG(INFO, TAG, "Zigbee Plugin Stopped");
// OCStop
IotivityStop:
OIC_LOG(INFO, TAG, "Stopping IoTivity...");
result = OCStop();
if (result != OC_STACK_OK)
{
OIC_LOG_V(ERROR, TAG, "OCStop Failed: %d", result);
return 0;
}
OIC_LOG(INFO, TAG, "Application Completed Successfully");
return 0;
}
/**
* Provisioning client sample using ProvisioningAPI
*/
int main()
{
OCStackResult res = OC_STACK_OK;
int unused;
(void)unused;
// Initialize Persistent Storage for SVR database
OCPersistentStorage ps = { .open = NULL,
.read = NULL,
.write = NULL,
.close = NULL,
.unlink = NULL };
ps.open = client_fopen;
ps.read = fread;
ps.write = fwrite;
ps.close = fclose;
ps.unlink = unlink;
OCRegisterPersistentStorageHandler(&ps);
if (OC_STACK_OK != OCInit(NULL, 0, OC_CLIENT_SERVER))
{
OC_LOG(ERROR, TAG, "OCStack init error");
goto error;
}
OCProvisionDev_t* pDeviceList = NULL;
res = OCDiscoverUnownedDevices(PREDEFINED_TIMEOUT, &pDeviceList);
if(OC_STACK_OK != res)
{
OC_LOG_V(ERROR, TAG, "Failed to PMDeviceDiscovery : %d", res);
goto error;
}
OCProvisionDev_t* pCurDev = pDeviceList;
int i;
while(pCurDev !=NULL)
{
for(i = 0; i < UUID_LENGTH; i++)
printf("%c", pCurDev->doxm->deviceID.id[i]);
printf("\n");
pCurDev = pCurDev->next;
}
//Register callback function to each OxM
OTMCallbackData_t justWorksCBData = {.loadSecretCB=NULL,
.createSecureSessionCB=NULL,
.createSelectOxmPayloadCB=NULL,
.createOwnerTransferPayloadCB=NULL};
justWorksCBData.loadSecretCB = LoadSecretJustWorksCallback;
justWorksCBData.createSecureSessionCB = CreateSecureSessionJustWorksCallback;
justWorksCBData.createSelectOxmPayloadCB = CreateJustWorksSelectOxmPayload;
justWorksCBData.createOwnerTransferPayloadCB = CreateJustWorksOwnerTransferPayload;
OTMSetOwnershipTransferCallbackData(OIC_JUST_WORKS, &justWorksCBData);
OTMCallbackData_t pinBasedCBData = {.loadSecretCB=NULL,
.createSecureSessionCB=NULL,
.createSelectOxmPayloadCB=NULL,
.createOwnerTransferPayloadCB=NULL};
pinBasedCBData.loadSecretCB = InputPinCodeCallback;
pinBasedCBData.createSecureSessionCB = CreateSecureSessionRandomPinCallbak;
pinBasedCBData.createSelectOxmPayloadCB = CreatePinBasedSelectOxmPayload;
pinBasedCBData.createOwnerTransferPayloadCB = CreatePinBasedOwnerTransferPayload;
OTMSetOwnershipTransferCallbackData(OIC_RANDOM_DEVICE_PIN, &pinBasedCBData);
SetInputPinCB(&InputPinCB);
char* myContext = "OTM Context";
//Perform ownership transfer
res = OCDoOwnershipTransfer((void*)myContext, pDeviceList, OwnershipTransferCB);
if(OC_STACK_OK == res)
{
OC_LOG(INFO, TAG, "Request for ownership transfer is sent successfully.");
}
else
{
OC_LOG_V(ERROR, TAG, "Failed to OCDoOwnershipTransfer : %d", res);
}
gOwnershipState = 0;
while ( gOwnershipState == 0 )
{
if (OCProcess() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack process error");
goto error;
}
sleep(1);
}
// Credential & ACL provisioning between two devices.
OCProvisionDev_t *pOwnedList = NULL;
OCProvisionDev_t *pOwnedDevices [MAX_OWNED_DEVICE] = {0,};
int nOwnedDevice = 0;
res = OCDiscoverOwnedDevices(PREDEFINED_TIMEOUT, &pOwnedList);
if (OC_STACK_OK == res)
{
printf("################## Owned Device List #######################\n");
while (pOwnedList != NULL)
{
nOwnedDevice ++;
printf(" %d : ", nOwnedDevice);
for (int i = 0; i < UUID_LENGTH; i++)
{
printf("%c", pOwnedList->doxm->deviceID.id[i]);
}
printf("\n");
pOwnedDevices[nOwnedDevice] = pOwnedList;
pOwnedList = pOwnedList->next;
}
}
else
{
OC_LOG(ERROR, TAG, "Error while Owned Device Discovery");
}
int Device1 = 0;
int Device2 = 0;
printf("Select 2 devices for Credential & ACL provisioning\n");
printf("Device 1: ");
unused = scanf("%d", &Device1);
printf("Device 2: ");
unused = scanf("%d", &Device2);
gAcl1 = (OicSecAcl_t *)OICCalloc(1,sizeof(OicSecAcl_t));
if (NULL == gAcl1)
{
OC_LOG(ERROR, TAG, "Error while memory allocation");
goto error;
}
gAcl2 = (OicSecAcl_t *)OICCalloc(1,sizeof(OicSecAcl_t));
if (NULL == gAcl2)
{
OC_LOG(ERROR, TAG, "Error while memory allocation");
goto error;
}
printf("Input ACL for Device1\n");
if ( 0 == InputACL(gAcl1))
{
printf("Success Input ACL\n");
}
else
{
OC_LOG(ERROR, TAG, "InputACL error");
goto error;
}
printf("Input ACL for Device2\n");
if (0 == InputACL(gAcl2))
{
printf("Success Input ACL\n");
}
else
{
OC_LOG(ERROR, TAG, "InputACL error");
goto error;
}
char *ctx = "DUMMY";
OCProvisionPairwiseDevices(ctx,SYMMETRIC_PAIR_WISE_KEY, OWNER_PSK_LENGTH_128, pOwnedDevices[Device1],
gAcl1, pOwnedDevices[Device2], gAcl2, ProvisionPairwiseCB);
gOwnershipState = 0;
while ( gOwnershipState == 0 )
{
if (OCProcess() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack process error");
goto error;
}
sleep(1);
}
if (OCStop() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack process error");
goto error;
}
error:
deleteACL(gAcl1);
deleteACL(gAcl2);
OCDeleteDiscoveredDevices(&pDeviceList);
OCDeleteDiscoveredDevices(&pOwnedList);
return 0;
}
int main(int argc, char* argv[])
{
char host[] = "localhost";
char user[] = "test1";
char pass[] = "intel123";
char empstr[] = "";
OCRAInfo_t rainfo = {};
rainfo.hostname = host;
rainfo.port = 5222;
rainfo.xmpp_domain = host;
rainfo.username = user;
rainfo.password = pass;
rainfo.resource = empstr;
rainfo.user_jid = empstr;
rainfo.jidbound = jidbound;
int opt = 0;
while ((opt = getopt(argc, argv, "t:s:p:d:u:w:r:j:")) != -1)
{
switch(opt)
{
case 't':
TEST_CASE = atoi(optarg);
break;
case 's':
rainfo.hostname = optarg;
break;
case 'p':
rainfo.port = atoi(optarg);
break;
case 'd':
rainfo.xmpp_domain = optarg;
break;
case 'u':
rainfo.username = optarg;
break;
case 'w':
rainfo.password = optarg;
break;
case 'j':
rainfo.user_jid = optarg;
break;
case 'r':
rainfo.resource = optarg;
break;
default:
PrintUsage();
return -1;
}
}
if (OCSetRAInfo(&rainfo) != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "Error initiating remote access adapter");
return 0;
}
if ((TEST_CASE < TEST_DISCOVER_REQ || TEST_CASE >= MAX_TESTS))
{
PrintUsage();
return -1;
}
if (OCInit(NULL, 0, OC_CLIENT) != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
OIC_LOG(INFO, TAG, "Enter JID of remote server");
if (fgets(remoteServerJabberID, MAX_ADDR_STR_SIZE, stdin))
{
StripNewLineChar(remoteServerJabberID);
}
else
{
OIC_LOG(ERROR, TAG, "Bad input for jabberID");
return OC_STACK_INVALID_PARAM;
}
InitDiscovery(OC_LOW_QOS);
// Break from loop with Ctrl+C
OIC_LOG(INFO, TAG, "Press CTRL+C to stop the stack");
signal(SIGINT, handleSigInt);
while (!gQuitFlag)
{
if (OCProcess() != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
sleep(2);
}
OIC_LOG(INFO, TAG, "Exiting ocremoteaccessclient main loop...");
if (OCStop() != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack stop error");
}
return 0;
}
int main(int argc, char* argv[])
{
int opt;
struct timespec timeout;
OCPersistentStorage ps;
while ((opt = getopt(argc, argv, "u:t:c:d:p:")) != -1)
{
switch(opt)
{
case 'u':
UnicastDiscovery = atoi(optarg);
break;
case 't':
TestCase = atoi(optarg);
break;
case 'c':
ConnType = atoi(optarg);
break;
case 'd':
DevOwner = atoi(optarg);
break;
case 'p':
{
WithTcp = atoi(optarg);
if(WithTcp > 1)
{
PrintUsage();
return -1;
}
}
break;
default:
PrintUsage();
return -1;
}
}
if ((UnicastDiscovery != 0 && UnicastDiscovery != 1) ||
(TestCase < TEST_DISCOVER_REQ || TestCase >= MAX_TESTS)||
(ConnType < CT_ADAPTER_DEFAULT || ConnType >= MAX_CT))
{
PrintUsage();
return -1;
}
if(ConnType == CT_ADAPTER_DEFAULT || ConnType == CT_IP)
{
discoveryReqConnType = CT_DEFAULT;
}
else
{
OIC_LOG(INFO, TAG, "Using Default Connectivity type");
PrintUsage();
}
// Initialize Persistent Storage for SVR database
if (DevOwner)
ps = { client_fopen_devowner, fread, fwrite, fclose, unlink };
else
ps = { client_fopen_nondevowner, fread, fwrite, fclose, unlink };
OCRegisterPersistentStorageHandler(&ps);
/* Initialize OCStack*/
if (OCInit(NULL, 0, OC_CLIENT_SERVER) != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
InitDiscovery();
timeout.tv_sec = 0;
timeout.tv_nsec = 100000000L;
// Break from loop with Ctrl+C
OIC_LOG(INFO, TAG, "Entering occlient main loop...");
signal(SIGINT, handleSigInt);
while (!gQuitFlag)
{
if (OCProcess() != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
nanosleep(&timeout, NULL);
}
OIC_LOG(INFO, TAG, "Exiting occlient main loop...");
if (OCStop() != OC_STACK_OK)
{
OIC_LOG(ERROR, TAG, "OCStack stop error");
}
return 0;
}
int main(int argc, char* argv[])
{
int opt;
resourceList = NULL;
while ((opt = getopt(argc, argv, "u:t:c:")) != -1)
{
switch(opt)
{
case 'u':
UnicastDiscovery = atoi(optarg);
break;
case 't':
TestCase = atoi(optarg);
break;
case 'c':
Connectivity = atoi(optarg);
break;
default:
PrintUsage();
return -1;
}
}
if ((UnicastDiscovery != 0 && UnicastDiscovery != 1) ||
(TestCase < TEST_DISCOVER_REQ || TestCase >= MAX_TESTS) ||
(Connectivity < CT_ADAPTER_DEFAULT || Connectivity >= MAX_CT))
{
PrintUsage();
return -1;
}
/* Initialize OCStack*/
if (OCInit1(OC_CLIENT, OC_DEFAULT_FLAGS, OC_DEFAULT_FLAGS) != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
if(Connectivity == CT_ADAPTER_DEFAULT || Connectivity == CT_IP)
{
ConnType = CT_ADAPTER_IP;//CT_DEFAULT;
}
else
{
OC_LOG(INFO, TAG, "Default Connectivity type selected");
PrintUsage();
}
InitDiscovery();
// Break from loop with Ctrl+C
signal(SIGINT, handleSigInt);
while (!gQuitFlag)
{
if (OCProcess() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
sleep(2);
}
freeResourceList();
OC_LOG(INFO, TAG, "Exiting occlient main loop...");
if (OCStop() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack stop error");
}
return 0;
}
int main(int argc, char* argv[])
{
int opt;
while ((opt = getopt(argc, argv, "u:t:c:")) != -1)
{
switch(opt)
{
case 'u':
UNICAST_DISCOVERY = atoi(optarg);
break;
case 't':
TEST_CASE = atoi(optarg);
break;
case 'c':
OC_CONNTYPE = OCConnectivityType(atoi(optarg));
break;
default:
PrintUsage();
return -1;
}
}
if ((UNICAST_DISCOVERY != 0 && UNICAST_DISCOVERY != 1) ||
(TEST_CASE < TEST_DISCOVER_REQ || TEST_CASE >= MAX_TESTS) )
{
PrintUsage();
return -1;
}
/* Initialize OCStack*/
if (OCInit(NULL, 0, OC_CLIENT) != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
if (UNICAST_DISCOVERY)
{
printf("Enter IPv4 address of the Server hosting resource (Ex: 192.168.0.15)\n");
if (fgets(ipv4addr, IPV4_ADDR_SIZE, stdin))
{
//Strip newline char from ipv4addr
StripNewLineChar(ipv4addr);
}
else
{
OC_LOG(ERROR, TAG, "!! Bad input for IPV4 address. !!");
return OC_STACK_INVALID_PARAM;
}
}
if(UNICAST_DISCOVERY == 0 && TEST_CASE == TEST_DISCOVER_DEV_REQ)
{
InitDeviceDiscovery(OC_LOW_QOS);
}
else
{
InitDiscovery(OC_LOW_QOS);
}
// Break from loop with Ctrl+C
OC_LOG(INFO, TAG, "Entering occlient main loop...");
signal(SIGINT, handleSigInt);
while (!gQuitFlag)
{
if (OCProcess() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
sleep(2);
}
OC_LOG(INFO, TAG, "Exiting occlient main loop...");
if (OCStop() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack stop error");
}
return 0;
}
