resource/csdk/stack/samples/linux/SimpleClientServer/occlientcoll.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2014 Intel Mobile Communications GmbH All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <signal.h>
  25 #include <unistd.h>
  26 #include <ocstack.h>
  27 #include <iostream>
  28 #include <sstream>
  29 #include "logger.h"
  30 const char *getResult(OCStackResult result);
  31 std::string getIPAddrTBServer(OCClientResponse * clientResponse);
  32 std::string getPortTBServer(OCClientResponse * clientResponse);
  33 std::string getQueryStrForGetPut(const char * responsePayload);
  34
  35 #define TAG PCF("occlient")
  36 #define DEFAULT_CONTEXT_VALUE 0x99
  37 #ifndef MAX_LENGTH_IPv4_ADDR
  38 #define MAX_LENGTH_IPv4_ADDR 16
  39 #endif
  40
  41 typedef enum
  42 {
  43     TEST_INVALID = 0,
  44     TEST_GET_DEFAULT,
  45     TEST_GET_BATCH,
  46     TEST_GET_LINK_LIST,
  47     TEST_PUT_DEFAULT,
  48     TEST_PUT_BATCH,
  49     TEST_PUT_LINK_LIST,
  50     TEST_UNKNOWN_RESOURCE_GET_DEFAULT,
  51     TEST_UNKNOWN_RESOURCE_GET_BATCH,
  52     TEST_UNKNOWN_RESOURCE_GET_LINK_LIST,
  53     MAX_TESTS
  54 } CLIENT_TEST;
  55
  56 unsigned static int TEST = TEST_INVALID;
  57
  58 typedef struct
  59 {
  60     char text[30];
  61     CLIENT_TEST test;
  62 } testToTextMap;
  63
  64 testToTextMap queryInterface[] = {
  65         {"invalid", TEST_INVALID},
  66         {"?if=oic.if.baseline", TEST_GET_DEFAULT},
  67         {"?if=oic.if.b", TEST_GET_BATCH},
  68         {"?if=oic.if.ll", TEST_GET_LINK_LIST},
  69         {"?if=oic.if.baseline", TEST_UNKNOWN_RESOURCE_GET_DEFAULT},
  70         {"?if=oic.if.b", TEST_UNKNOWN_RESOURCE_GET_BATCH},
  71         {"?if=oic.if.ll", TEST_UNKNOWN_RESOURCE_GET_LINK_LIST},
  72         {"?if=oic.if.baseline", TEST_PUT_DEFAULT},
  73         {"?if=oic.if.b", TEST_PUT_BATCH},
  74         {"?if=oic.if.ll", TEST_PUT_LINK_LIST},
  75 };
  76
  77 static std::string putPayload = "{\"state\":\"off\",\"power\":\"0\"}";
  78
  79 //The following variable determines the interface protocol (IP, etc)
  80 //to be used for sending unicast messages. Default set to IP.
  81 static OCConnectivityType OC_CONNTYPE = CT_ADAPTER_IP;
  82 static const char * MULTICAST_RESOURCE_DISCOVERY_QUERY = "/oic/res";
  83
  84 // The handle for the observe registration
  85 OCDoHandle gObserveDoHandle;
  86 // After this crosses a threshold client deregisters for further observations
  87 int gNumObserveNotifies = 1;
  88
  89 int gQuitFlag = 0;
  90 /* SIGINT handler: set gQuitFlag to 1 for graceful termination */
  91 void handleSigInt(int signum)
  92 {
  93     if (signum == SIGINT)
  94     {
  95         gQuitFlag = 1;
  96     }
  97 }
  98
  99 // Forward Declaration
 100 OCStackApplicationResult getReqCB(void* ctx, OCDoHandle handle, OCClientResponse * clientResponse);
 101 int InitGetRequestToUnavailableResource(OCClientResponse * clientResponse);
 102 int InitObserveRequest(OCClientResponse * clientResponse);
 103 int InitPutRequest(OCClientResponse * clientResponse);
 104 int InitGetRequest(OCClientResponse * clientResponse);
 105 int InitDiscovery();
 106
 107 void PrintUsage()
 108 {
 109     OC_LOG(INFO, TAG, "Usage : occlientcoll -t <Test Case> -c <CA connectivity Type>");
 110     OC_LOG(INFO, TAG, "-c <0|1> : IPv4/IPv6 (IPv6 not currently supported)");
 111     OC_LOG(INFO, TAG, "Test Case 1 : Discover Resources && Initiate GET Request on an "\
 112             "available resource using default interface.");
 113     OC_LOG(INFO, TAG, "Test Case 2 : Discover Resources && Initiate GET Request on an "\
 114                  "available resource using batch interface.");
 115     OC_LOG(INFO, TAG, "Test Case 3 : Discover Resources && Initiate GET Request on an "\
 116                  "available resource using link list interface.");
 117     OC_LOG(INFO, TAG, "Test Case 4 : Discover Resources && Initiate GET & PUT Request on an "\
 118                  "available resource using default interface.");
 119     OC_LOG(INFO, TAG, "Test Case 5 : Discover Resources && Initiate GET & PUT Request on an "\
 120                  "available resource using batch interface.");
 121     OC_LOG(INFO, TAG, "Test Case 6 : Discover Resources && Initiate GET & PUT Request on an "\
 122                  "available resource using link list interface.");
 123     OC_LOG(INFO, TAG, "Test Case 7 : Discover Resources && Initiate GET Request on an "\
 124                  "unavailable resource using default interface.");
 125     OC_LOG(INFO, TAG, "Test Case 8 : Discover Resources && Initiate GET Request on an "\
 126                  "unavailable resource using batch interface.");
 127     OC_LOG(INFO, TAG, "Test Case 9 : Discover Resources && Initiate GET Request on an "\
 128                  "unavailable resource using link list interface.");
 129 }
 130
 131 OCStackApplicationResult putReqCB(void* ctx, OCDoHandle handle, OCClientResponse * clientResponse)
 132 {
 133     if(clientResponse == NULL)
 134     {
 135         OC_LOG(INFO, TAG, "The clientResponse is NULL");
 136         return   OC_STACK_DELETE_TRANSACTION;
 137     }
 138     if(ctx == (void*)DEFAULT_CONTEXT_VALUE)
 139     {
 140         OC_LOG_V(INFO, TAG, "Callback Context for PUT query recvd successfully");
 141         OC_LOG_V(INFO, TAG, "JSON = %s =============> Discovered", clientResponse->resJSONPayload);
 142     }
 143
 144     return OC_STACK_KEEP_TRANSACTION;
 145 }
 146
 147 OCStackApplicationResult getReqCB(void* ctx, OCDoHandle handle, OCClientResponse * clientResponse)
 148 {
 149     OC_LOG_V(INFO, TAG, "StackResult: %s",
 150             getResult(clientResponse->result));
 151     if(ctx == (void*)DEFAULT_CONTEXT_VALUE)
 152     {
 153         OC_LOG_V(INFO, TAG, "SEQUENCE NUMBER: %d", clientResponse->sequenceNumber);
 154         if(clientResponse->sequenceNumber == 0)
 155         {
 156             OC_LOG_V(INFO, TAG, "Callback Context for GET query recvd successfully");
 157             OC_LOG_V(INFO, TAG, "Fnd' Rsrc': %s", clientResponse->resJSONPayload);
 158         }
 159         else
 160         {
 161             OC_LOG_V(INFO, TAG, "Callback Context for Get recvd successfully %d",
 162                     gNumObserveNotifies);
 163             OC_LOG_V(INFO, TAG, "Fnd' Rsrc': %s", clientResponse->resJSONPayload);
 164             gNumObserveNotifies++;
 165             if (gNumObserveNotifies == 3)
 166             {
 167                 if (OCCancel (gObserveDoHandle, OC_LOW_QOS, NULL, 0) != OC_STACK_OK)
 168                 {
 169                     OC_LOG(ERROR, TAG, "Observe cancel error");
 170                 }
 171             }
 172         }
 173     }
 174     if(TEST == TEST_PUT_DEFAULT || TEST == TEST_PUT_BATCH || TEST == TEST_PUT_LINK_LIST)
 175     {
 176         InitPutRequest(clientResponse);
 177     }
 178     return OC_STACK_KEEP_TRANSACTION;
 179 }
 180
 181
 182 // This is a function called back when a device is discovered
 183 OCStackApplicationResult discoveryReqCB(void* ctx, OCDoHandle handle,
 184         OCClientResponse * clientResponse)
 185 {
 186     OC_LOG(INFO, TAG,
 187             "Entering discoveryReqCB (Application Layer CB)");
 188     OC_LOG_V(INFO, TAG, "StackResult: %s",
 189             getResult(clientResponse->result));
 190
 191     if (ctx == (void*) DEFAULT_CONTEXT_VALUE)
 192     {
 193         OC_LOG_V(INFO, TAG, "Callback Context recvd successfully");
 194     }
 195
 196     OC_LOG_V(INFO, TAG,
 197             "Device =============> Discovered %s @ %d.%d.%d.%d:%d",
 198             clientResponse->resJSONPayload, clientResponse->devAddr.addr, clientResponse->devAddr.port);
 199
 200     if(TEST == TEST_UNKNOWN_RESOURCE_GET_DEFAULT || TEST == TEST_UNKNOWN_RESOURCE_GET_BATCH ||\
 201             TEST == TEST_UNKNOWN_RESOURCE_GET_LINK_LIST)
 202     {
 203         InitGetRequestToUnavailableResource(clientResponse);
 204     }
 205     else
 206     {
 207         InitGetRequest(clientResponse);
 208     }
 209     return OC_STACK_KEEP_TRANSACTION;
 210 }
 211
 212
 213 int InitGetRequestToUnavailableResource(OCClientResponse * clientResponse)
 214 {
 215     OCStackResult ret;
 216     OCCallbackData cbData;
 217     std::ostringstream getQuery;
 218     getQuery << "coap://" << clientResponse->devAddr.addr << ":" <<
 219             clientResponse->devAddr.port << "/SomeUnknownResource";
 220     cbData.cb = getReqCB;
 221     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
 222     cbData.cd = NULL;
 223
 224     ret = OCDoResource(NULL, OC_REST_GET, getQuery.str().c_str(), 0, 0, OC_CONNTYPE, OC_LOW_QOS,
 225             &cbData, NULL, 0);
 226     if (ret != OC_STACK_OK)
 227     {
 228         OC_LOG(ERROR, TAG, "OCStack resource error");
 229     }
 230     return ret;
 231 }
 232
 233
 234 int InitObserveRequest(OCClientResponse * clientResponse)
 235 {
 236     OCStackResult ret;
 237     OCCallbackData cbData;
 238     OCDoHandle handle;
 239     std::ostringstream obsReg;
 240     obsReg << "coap://" << clientResponse->devAddr.addr << ":" <<
 241             clientResponse->devAddr.addr <<
 242             getQueryStrForGetPut(clientResponse->resJSONPayload);
 243     cbData.cb = getReqCB;
 244     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
 245     cbData.cd = NULL;
 246     OC_LOG_V(INFO, TAG, "OBSERVE payload from client = %s ", putPayload.c_str());
 247
 248     ret = OCDoResource(&handle, OC_REST_OBSERVE, obsReg.str().c_str(), 0, 0, OC_CONNTYPE,
 249             OC_LOW_QOS, &cbData, NULL, 0);
 250     if (ret != OC_STACK_OK)
 251     {
 252         OC_LOG(ERROR, TAG, "OCStack resource error");
 253     }
 254     else
 255     {
 256         gObserveDoHandle = handle;
 257     }
 258     return ret;
 259 }
 260
 261
 262 int InitPutRequest(OCClientResponse * clientResponse)
 263 {
 264     OCStackResult ret;
 265     OCCallbackData cbData;
 266     //* Make a PUT query*/
 267     std::ostringstream getQuery;
 268     getQuery << "coap://" << clientResponse->devAddr.addr << ":" <<
 269             clientResponse->devAddr.port <<
 270             "/a/room" << queryInterface[TEST].text;
 271     cbData.cb = putReqCB;
 272     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
 273     cbData.cd = NULL;
 274     OC_LOG_V(INFO, TAG, "PUT payload from client = %s ", putPayload.c_str());
 275
 276     ret = OCDoResource(NULL, OC_REST_PUT, getQuery.str().c_str(), 0, putPayload.c_str(),
 277                         OC_CONNTYPE, OC_LOW_QOS, &cbData, NULL, 0);
 278     if (ret != OC_STACK_OK)
 279     {
 280         OC_LOG(ERROR, TAG, "OCStack resource error");
 281     }
 282     return ret;
 283 }
 284
 285
 286 int InitGetRequest(OCClientResponse * clientResponse)
 287 {
 288     OCStackResult ret;
 289     OCCallbackData cbData;
 290
 291     //* Make a GET query*/
 292     std::ostringstream getQuery;
 293     getQuery << "coap://" << clientResponse->devAddr.addr << ":" <<
 294             clientResponse->devAddr.port <<
 295             "/a/room" << queryInterface[TEST].text;
 296
 297     std::cout << "Get Query: " << getQuery.str() << std::endl;
 298
 299     cbData.cb = getReqCB;
 300     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
 301     cbData.cd = NULL;
 302     ret = OCDoResource(NULL, OC_REST_GET,
 303             getQuery.str().c_str(), 0, 0, OC_CONNTYPE, OC_LOW_QOS,
 304             &cbData, NULL, 0);
 305     if (ret != OC_STACK_OK)
 306     {
 307         OC_LOG(ERROR, TAG, "OCStack resource error");
 308     }
 309     return ret;
 310 }
 311
 312 int InitDiscovery()
 313 {
 314     OCStackResult ret;
 315     OCCallbackData cbData;
 316     /* Start a discovery query*/
 317     char szQueryUri[64] = { 0 };
 318
 319     strcpy(szQueryUri, MULTICAST_RESOURCE_DISCOVERY_QUERY);
 320
 321     cbData.cb = discoveryReqCB;
 322     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
 323     cbData.cd = NULL;
 324     ret = OCDoResource(NULL, OC_REST_DISCOVER, szQueryUri, 0, 0, CT_DEFAULT,
 325                         OC_LOW_QOS,
 326             &cbData, NULL, 0);
 327     if (ret != OC_STACK_OK)
 328     {
 329         OC_LOG(ERROR, TAG, "OCStack resource error");
 330     }
 331     return ret;
 332 }
 333
 334 int main(int argc, char* argv[])
 335 {
 336     int opt;
 337
 338     while ((opt = getopt(argc, argv, "t:c:")) != -1)
 339     {
 340         switch (opt)
 341         {
 342             case 't':
 343                 TEST = atoi(optarg);
 344                 break;
 345             case 'c':
 346                 OC_CONNTYPE = CT_ADAPTER_IP;
 347                 break;
 348             default:
 349                 PrintUsage();
 350                 return -1;
 351         }
 352     }
 353     if (TEST <= TEST_INVALID || TEST >= MAX_TESTS)
 354     {
 355         PrintUsage();
 356         return -1;
 357     }
 358
 359     /* Initialize OCStack*/
 360     if (OCInit(NULL, 0, OC_CLIENT) != OC_STACK_OK)
 361     {
 362         OC_LOG(ERROR, TAG, "OCStack init error");
 363         return 0;
 364     }
 365
 366     InitDiscovery();
 367
 368     // Break from loop with Ctrl+C
 369     OC_LOG(INFO, TAG, "Entering occlient main loop...");
 370     signal(SIGINT, handleSigInt);
 371     while (!gQuitFlag)
 372     {
 373
 374         if (OCProcess() != OC_STACK_OK)
 375         {
 376             OC_LOG(ERROR, TAG, "OCStack process error");
 377             return 0;
 378         }
 379
 380         sleep(2);
 381     } OC_LOG(INFO, TAG, "Exiting occlient main loop...");
 382
 383     if (OCStop() != OC_STACK_OK)
 384     {
 385         OC_LOG(ERROR, TAG, "OCStack stop error");
 386     }
 387
 388     return 0;
 389 }
 390
 391 std::string getQueryStrForGetPut(const char * responsePayload)
 392 {
 393
 394     std::string jsonPayload(responsePayload);
 395
 396     return "/a/room";
 397 }
 398