resource/csdk/stack/samples/linux/secure/occlientbasicops.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 <iostream>
  27 #include <sstream>
  28 #include "ocstack.h"
  29 #include "logger.h"
  30 #include "occlientbasicops.h"
  31 #include "cJSON.h"
  32 #include "common.h"
  33
  34 #define TAG "occlientbasicops"
  35 static int UNICAST_DISCOVERY = 0;
  36 static int TEST_CASE = 0;
  37
  38 static int IPV4_ADDR_SIZE = 16;
  39 static char UNICAST_DISCOVERY_QUERY[] = "coap://%s:6298/oic/res";
  40 static char MULTICAST_DISCOVERY_QUERY[] = "/oic/res";
  41
  42 static std::string putPayload = "{\"oic\":[{\"rep\":{\"state\":\"off\",\"power\":10}}]}";
  43 static std::string coapServerIP;
  44 static std::string coapServerPort;
  45 static std::string coapServerResource;
  46 static int coapSecureResource;
  47 static OCConnectivityType ocConnType;
  48
  49
  50 //Secure Virtual Resource database for Iotivity Client application
  51 //It contains Client's Identity and the PSK credentials
  52 //of other devices which the client trusts
  53 static char CRED_FILE[] = "oic_svr_db_client.json";
  54
  55
  56 int gQuitFlag = 0;
  57
  58 /* SIGINT handler: set gQuitFlag to 1 for graceful termination */
  59 void handleSigInt(int signum)
  60 {
  61     if (signum == SIGINT)
  62     {
  63         gQuitFlag = 1;
  64     }
  65 }
  66
  67 static void PrintUsage()
  68 {
  69     OC_LOG(INFO, TAG, "Usage : occlient -u <0|1> -t <1|2|3>");
  70     OC_LOG(INFO, TAG, "-u <0|1> : Perform multicast/unicast discovery of resources");
  71     OC_LOG(INFO, TAG, "-t 1 : Discover Resources");
  72     OC_LOG(INFO, TAG, "-t 2 : Discover Resources and"
  73             " Initiate Nonconfirmable Get/Put/Post Requests");
  74     OC_LOG(INFO, TAG, "-t 3 : Discover Resources and Initiate Confirmable Get/Put/Post Requests");
  75 }
  76
  77 OCStackResult InvokeOCDoResource(std::ostringstream &query,
  78         OCMethod method, OCQualityOfService qos,
  79         OCClientResponseHandler cb, OCHeaderOption * options, uint8_t numOptions)
  80 {
  81     OCStackResult ret;
  82     OCCallbackData cbData;
  83
  84     cbData.cb = cb;
  85     cbData.context = NULL;
  86     cbData.cd = NULL;
  87
  88     ret = OCDoResource(NULL, method, query.str().c_str(), 0,
  89             (method == OC_REST_PUT || method == OC_REST_POST) ? putPayload.c_str() : NULL,
  90             ocConnType, qos, &cbData, options, numOptions);
  91
  92     if (ret != OC_STACK_OK)
  93     {
  94         OC_LOG_V(ERROR, TAG, "OCDoResource returns error %d with method %d", ret, method);
  95     }
  96
  97     return ret;
  98 }
  99
 100 OCStackApplicationResult putReqCB(void* ctx, OCDoHandle handle, OCClientResponse * clientResponse)
 101 {
 102     OC_LOG(INFO, TAG, "Callback Context for PUT recvd successfully");
 103
 104     if(clientResponse)
 105     {
 106         OC_LOG_V(INFO, TAG, "StackResult: %s",  getResult(clientResponse->result));
 107         OC_LOG_V(INFO, TAG, "JSON = %s =============> Put Response", clientResponse->resJSONPayload);
 108     }
 109     return OC_STACK_DELETE_TRANSACTION;
 110 }
 111
 112 OCStackApplicationResult postReqCB(void *ctx, OCDoHandle handle, OCClientResponse *clientResponse)
 113 {
 114     OC_LOG(INFO, TAG, "Callback Context for POST recvd successfully");
 115
 116     if(clientResponse)
 117     {
 118         OC_LOG_V(INFO, TAG, "StackResult: %s",  getResult(clientResponse->result));
 119         OC_LOG_V(INFO, TAG, "JSON = %s =============> Post Response",
 120                 clientResponse->resJSONPayload);
 121     }
 122     return OC_STACK_DELETE_TRANSACTION;
 123 }
 124
 125 OCStackApplicationResult getReqCB(void* ctx, OCDoHandle handle, OCClientResponse * clientResponse)
 126 {
 127     OC_LOG(INFO, TAG, "Callback Context for GET query recvd successfully");
 128
 129     if(clientResponse)
 130     {
 131         OC_LOG_V(INFO, TAG, "StackResult: %s",  getResult(clientResponse->result));
 132         OC_LOG_V(INFO, TAG, "SEQUENCE NUMBER: %d", clientResponse->sequenceNumber);
 133         OC_LOG_V(INFO, TAG, "JSON = %s =============> Get Response",
 134                 clientResponse->resJSONPayload);
 135     }
 136     return OC_STACK_DELETE_TRANSACTION;
 137 }
 138
 139 // This is a function called back when a device is discovered
 140 OCStackApplicationResult discoveryReqCB(void* ctx, OCDoHandle handle,
 141         OCClientResponse * clientResponse)
 142 {
 143     OC_LOG(INFO, TAG, "Callback Context for DISCOVER query recvd successfully");
 144
 145     if (clientResponse)
 146     {
 147         OC_LOG_V(INFO, TAG, "StackResult: %s", getResult(clientResponse->result));
 148         OC_LOG_V(INFO, TAG,
 149                 "Device =============> Discovered %s @ %s:%d",
 150                 clientResponse->resJSONPayload, clientResponse->devAddr.addr, clientResponse->devAddr.port);
 151
 152         ocConnType = clientResponse->connType;
 153
 154         if (parseClientResponse(clientResponse) != -1)
 155         {
 156             switch(TEST_CASE)
 157             {
 158                 case TEST_NON_CON_OP:
 159                     InitGetRequest(OC_LOW_QOS);
 160                     InitPutRequest(OC_LOW_QOS);
 161                     //InitPostRequest(OC_LOW_QOS);
 162                     break;
 163                 case TEST_CON_OP:
 164                     InitGetRequest(OC_HIGH_QOS);
 165                     InitPutRequest(OC_HIGH_QOS);
 166                     //InitPostRequest(OC_HIGH_QOS);
 167                     break;
 168             }
 169         }
 170     }
 171
 172     return (UNICAST_DISCOVERY) ? OC_STACK_DELETE_TRANSACTION : OC_STACK_KEEP_TRANSACTION ;
 173
 174 }
 175
 176 int InitPutRequest(OCQualityOfService qos)
 177 {
 178     OC_LOG_V(INFO, TAG, "\n\nExecuting %s", __func__);
 179     std::ostringstream query;
 180     query << (coapSecureResource ? "coaps://" : "coap://") << coapServerIP
 181         << ":" << coapServerPort  << coapServerResource;
 182     return (InvokeOCDoResource(query, OC_REST_PUT,
 183             ((qos == OC_HIGH_QOS) ? OC_HIGH_QOS: OC_LOW_QOS), putReqCB, NULL, 0));
 184 }
 185
 186 int InitPostRequest(OCQualityOfService qos)
 187 {
 188     OCStackResult result;
 189     OC_LOG_V(INFO, TAG, "\n\nExecuting %s", __func__);
 190     std::ostringstream query;
 191     query << (coapSecureResource ? "coaps://" : "coap://") << coapServerIP
 192         << ":" << coapServerPort << coapServerResource;
 193
 194     // First POST operation (to create an LED instance)
 195     result = InvokeOCDoResource(query, OC_REST_POST,
 196             ((qos == OC_HIGH_QOS) ? OC_HIGH_QOS: OC_LOW_QOS),
 197             postReqCB, NULL, 0);
 198     if (OC_STACK_OK != result)
 199     {
 200         // Error can happen if for example, network connectivity is down
 201         OC_LOG(INFO, TAG, "First POST call did not succeed");
 202     }
 203
 204     // Second POST operation (to create an LED instance)
 205     result = InvokeOCDoResource(query, OC_REST_POST,
 206             ((qos == OC_HIGH_QOS) ? OC_HIGH_QOS: OC_LOW_QOS),
 207             postReqCB, NULL, 0);
 208     if (OC_STACK_OK != result)
 209     {
 210         OC_LOG(INFO, TAG, "Second POST call did not succeed");
 211     }
 212
 213     // This POST operation will update the original resourced /a/led
 214     return (InvokeOCDoResource(query, OC_REST_POST,
 215                 ((qos == OC_HIGH_QOS) ? OC_HIGH_QOS: OC_LOW_QOS),
 216                 postReqCB, NULL, 0));
 217 }
 218
 219 int InitGetRequest(OCQualityOfService qos)
 220 {
 221     OC_LOG_V(INFO, TAG, "\n\nExecuting %s", __func__);
 222     std::ostringstream query;
 223     query << (coapSecureResource ? "coaps://" : "coap://") << coapServerIP
 224         << ":" << coapServerPort << coapServerResource;
 225
 226     return (InvokeOCDoResource(query, OC_REST_GET, (qos == OC_HIGH_QOS)?
 227             OC_HIGH_QOS:OC_LOW_QOS, getReqCB, NULL, 0));
 228 }
 229
 230 int InitDiscovery()
 231 {
 232     OCStackResult ret;
 233     OCMethod method;
 234     OCCallbackData cbData;
 235     char szQueryUri[MAX_URI_LENGTH] = { 0 };
 236     OCConnectivityType discoveryReqConnType;
 237
 238     if (UNICAST_DISCOVERY)
 239     {
 240         char ipv4addr[IPV4_ADDR_SIZE];
 241         printf("Enter IPv4 address of the Server hosting secure resource (Ex: 11.12.13.14)\n");
 242         if (fgets(ipv4addr, IPV4_ADDR_SIZE, stdin))
 243         {
 244             //Strip newline char from ipv4addr
 245             StripNewLineChar(ipv4addr);
 246             snprintf(szQueryUri, sizeof(szQueryUri), UNICAST_DISCOVERY_QUERY, ipv4addr);
 247         }
 248         else
 249         {
 250             OC_LOG(ERROR, TAG, "!! Bad input for IPV4 address. !!");
 251             return OC_STACK_INVALID_PARAM;
 252         }
 253         discoveryReqConnType = CT_ADAPTER_IP;
 254         method = OC_REST_GET;
 255     }
 256     else
 257     {
 258         //Send discovery request on Wifi and Ethernet interface
 259         discoveryReqConnType = CT_DEFAULT;
 260         strcpy(szQueryUri, MULTICAST_DISCOVERY_QUERY);
 261         method = OC_REST_DISCOVER;
 262     }
 263
 264     cbData.cb = discoveryReqCB;
 265     cbData.context = NULL;
 266     cbData.cd = NULL;
 267
 268     /* Start a discovery query*/
 269     OC_LOG_V(INFO, TAG, "Initiating %s Resource Discovery : %s\n",
 270         (UNICAST_DISCOVERY) ? "Unicast" : "Multicast",
 271         szQueryUri);
 272
 273     ret = OCDoResource(NULL, method, szQueryUri, 0, 0,
 274             discoveryReqConnType, OC_LOW_QOS,
 275             &cbData, NULL, 0);
 276     if (ret != OC_STACK_OK)
 277     {
 278         OC_LOG(ERROR, TAG, "OCStack resource error");
 279     }
 280     return ret;
 281 }
 282
 283 FILE* client_fopen(const char *path, const char *mode)
 284 {
 285     (void)path;
 286     return fopen(CRED_FILE, mode);
 287 }
 288
 289 int main(int argc, char* argv[])
 290 {
 291     int opt;
 292     struct timespec timeout;
 293
 294     while ((opt = getopt(argc, argv, "u:t:")) != -1)
 295     {
 296         switch(opt)
 297         {
 298             case 'u':
 299                 UNICAST_DISCOVERY = atoi(optarg);
 300                 break;
 301             case 't':
 302                 TEST_CASE = atoi(optarg);
 303                 break;
 304             default:
 305                 PrintUsage();
 306                 return -1;
 307         }
 308     }
 309
 310     if ((UNICAST_DISCOVERY != 0 && UNICAST_DISCOVERY != 1) ||
 311             (TEST_CASE < TEST_DISCOVER_REQ || TEST_CASE >= MAX_TESTS) )
 312     {
 313         PrintUsage();
 314         return -1;
 315     }
 316
 317     // Initialize Persistent Storage for SVR database
 318     OCPersistentStorage ps = {};
 319     ps.open = client_fopen;
 320     ps.read = fread;
 321     ps.write = fwrite;
 322     ps.close = fclose;
 323     ps.unlink = unlink;
 324     OCRegisterPersistentStorageHandler(&ps);
 325
 326     /* Initialize OCStack*/
 327     if (OCInit(NULL, 0, OC_CLIENT_SERVER) != OC_STACK_OK)
 328     {
 329         OC_LOG(ERROR, TAG, "OCStack init error");
 330         return 0;
 331     }
 332
 333     InitDiscovery();
 334
 335     timeout.tv_sec  = 0;
 336     timeout.tv_nsec = 100000000L;
 337
 338     // Break from loop with Ctrl+C
 339     OC_LOG(INFO, TAG, "Entering occlient main loop...");
 340     signal(SIGINT, handleSigInt);
 341     while (!gQuitFlag)
 342     {
 343         if (OCProcess() != OC_STACK_OK)
 344         {
 345             OC_LOG(ERROR, TAG, "OCStack process error");
 346             return 0;
 347         }
 348
 349         nanosleep(&timeout, NULL);
 350     }
 351     OC_LOG(INFO, TAG, "Exiting occlient main loop...");
 352
 353     if (OCStop() != OC_STACK_OK)
 354     {
 355         OC_LOG(ERROR, TAG, "OCStack stop error");
 356     }
 357
 358     return 0;
 359 }
 360
 361 std::string getPortTBServer(OCClientResponse * clientResponse)
 362 {
 363     if(!clientResponse) return "";
 364     std::ostringstream ss;
 365     ss << clientResponse->devAddr.port;
 366     return ss.str();
 367 }
 368
 369 int parseClientResponse(OCClientResponse * clientResponse)
 370 {
 371     int port = -1;
 372     cJSON * root = NULL;
 373     cJSON * oc = NULL;
 374
 375     // Initialize all global variables
 376     coapServerResource.clear();
 377     coapServerPort.clear();
 378     coapServerIP.clear();
 379     coapSecureResource = 0;
 380
 381     root = cJSON_Parse((char *)(clientResponse->resJSONPayload));
 382     if (!root)
 383     {
 384         return -1;
 385     }
 386
 387     oc = cJSON_GetObjectItem(root,"oic");
 388     if (!oc)
 389     {
 390         return -1;
 391     }
 392
 393     if (oc->type == cJSON_Array)
 394     {
 395         int numRsrcs =  cJSON_GetArraySize(oc);
 396         for(int i = 0; i < numRsrcs; i++)
 397         {
 398             cJSON * resource = cJSON_GetArrayItem(oc, i);
 399             if (cJSON_GetObjectItem(resource, "href"))
 400             {
 401                 coapServerResource.assign(cJSON_GetObjectItem(resource, "href")->valuestring);
 402             }
 403             else
 404             {
 405                 coapServerResource = "";
 406             }
 407             OC_LOG_V(INFO, TAG, "Uri -- %s", coapServerResource.c_str());
 408
 409             cJSON * prop = cJSON_GetObjectItem(resource,"prop");
 410             if (prop)
 411             {
 412                 cJSON * policy = cJSON_GetObjectItem(prop,"p");
 413                 if (policy)
 414                 {
 415                     // If this is a secure resource, the info about the port at which the
 416                     // resource is hosted on server is embedded inside discovery JSON response
 417                     if (cJSON_GetObjectItem(policy, "sec"))
 418                     {
 419                         if ((cJSON_GetObjectItem(policy, "sec")->valueint) == 1)
 420                         {
 421                             coapSecureResource = 1;
 422                         }
 423                     }
 424                     OC_LOG_V(INFO, TAG, "Secure -- %s", coapSecureResource == 1 ? "YES" : "NO");
 425                     if (cJSON_GetObjectItem(policy, "port"))
 426                     {
 427                         port = cJSON_GetObjectItem(policy, "port")->valueint;
 428                         OC_LOG_V(INFO, TAG, "Hosting Server Port (embedded inside JSON) -- %u", port);
 429
 430                         std::ostringstream ss;
 431                         ss << port;
 432                         coapServerPort = ss.str();
 433                     }
 434                 }
 435             }
 436
 437             // If we discovered a secure resource, exit from here
 438             if (coapSecureResource)
 439             {
 440                 break;
 441             }
 442         }
 443     }
 444     cJSON_Delete(root);
 445
 446     coapServerIP = clientResponse->devAddr.addr;
 447     if (port == -1)
 448     {
 449         coapServerPort = getPortTBServer(clientResponse);
 450         OC_LOG_V(INFO, TAG, "Hosting Server Port -- %s", coapServerPort.c_str());
 451     }
 452     return 0;
 453 }
 454