resource/csdk/connectivity/samples/arduino/casample.cpp

   1 /******************************************************************
   2  *
   3  * Copyright 2014 Samsung Electronics 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 <ctype.h>
  22 #include <errno.h>
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #include "cacommon.h"
  29 #include "cainterface.h"
  30 #include "Arduino.h"
  31
  32 #ifdef ARDUINOWIFI
  33 #include "WiFi.h"
  34 #elif defined ARDUINOETH
  35 #include "Ethernet.h"
  36 #endif
  37
  38 #include "oic_malloc.h"
  39
  40 #define MAX_BUF_LEN 100 //1024
  41 #define MAX_OPT_LEN 16
  42 #define PORT_LENGTH 5
  43
  44 static bool g_isLeSelected = false;
  45
  46 static void PrintMenu();
  47 static void Process();
  48 static void Initialize();
  49 static void StartListeningServer();
  50 static void StartDiscoveryServer();
  51 static void SendRequest();
  52 static void SendRequestAll();
  53 static void SendResponse(CAEndpoint_t *endpoint, const CAInfo_t* info);
  54 static void SendNotification();
  55 static void SelectNetwork();
  56 static void UnselectNetwork();
  57 static void HandleRequestResponse();
  58 static void GetNetworkInfo();
  59
  60 static void RequestHandler(const CAEndpoint_t *object, const CARequestInfo_t *requestInfo);
  61 static void ResponseHandler(const CAEndpoint_t *object, const CAResponseInfo_t *responseInfo);
  62 static void ErrorHandler(const CAEndpoint_t *object, const CAErrorInfo_t* errorInfo);
  63 static void Terminate();
  64
  65 void GetData(char *readInput, size_t bufferLength, size_t *dataLength)
  66 {
  67     if (!readInput || bufferLength == 0 || !dataLength)
  68     {
  69         Serial.println("Invalid buffer");
  70         return;
  71     }
  72
  73     while (!Serial.available())
  74     {
  75         delay(500);
  76     }
  77     int len = 0;
  78     while (Serial.available())
  79     {
  80         delay(100);
  81         char c = Serial.read();
  82         if ('\n' != c && '\r' != c && len < bufferLength - 1)
  83         {
  84             readInput[len++] = c;
  85         }
  86         else
  87         {
  88             break;
  89         }
  90     }
  91
  92     readInput[len] = '\0';
  93     Serial.flush();
  94     Serial.print("PD:");
  95     Serial.println(readInput);
  96     (*dataLength) = len;
  97 }
  98
  99 bool ParseData(char *buf, char *url, char *port, char *resourceUri)
 100 {
 101     char *slash = strchr(buf, '/');
 102     if (!slash)
 103     {
 104         return false;
 105     }
 106
 107     strcpy(resourceUri, slash);
 108
 109     char *dot = strchr(buf, '.');
 110     if (dot && dot < slash)
 111     {
 112         char *colon = strchr(buf, ':');
 113
 114         if (colon)
 115         {
 116             strncpy(port, colon, slash - colon);
 117             memmove(port, port+1, strlen(port));
 118         }
 119         if (colon && colon < slash)
 120         {
 121             strncpy(url, buf, colon - buf);
 122             return true;
 123         }
 124     }
 125
 126     strncpy(url, buf, slash - buf);
 127     return true;
 128 }
 129
 130 CATransportAdapter_t GetConnectivityType()
 131 {
 132     char type[2] = {0};
 133     Serial.println("Select network");
 134     Serial.println("IP: 0");
 135     Serial.println("GATT (BLE): 1");
 136     Serial.println("RFCOMM (EDR): 2");
 137
 138     size_t typeLen = 0;
 139     GetData(type, sizeof(type), &typeLen);
 140     if (0 >= typeLen)
 141     {
 142         Serial.println("i/p err,default ethernet");
 143         return CA_ADAPTER_IP;
 144     }
 145     switch (type[0])
 146     {
 147         case '0':
 148             return CA_ADAPTER_IP;
 149         case '1':
 150             return CA_ADAPTER_GATT_BTLE;
 151         case '2':
 152             return CA_ADAPTER_RFCOMM_BTEDR;
 153     }
 154     return CA_ADAPTER_IP;
 155 }
 156
 157 void setup()
 158 {
 159     Serial.begin (115200);
 160
 161     Serial.println("============");
 162     Serial.println("CA SAMPLE");
 163     Serial.println("============");
 164     PrintMenu();
 165 }
 166
 167 void loop()
 168 {
 169     char buffer[5] = {0};
 170     size_t len;
 171     if (Serial.available() > 0)
 172     {
 173         GetData(buffer, sizeof(buffer), &len);
 174         if (0 >= len)
 175         {
 176             Serial.println("i/p err");
 177             return;
 178         }
 179         switch (toupper(buffer[0]))
 180         {
 181             case 'M': // menu
 182                 PrintMenu();
 183                 break;
 184
 185             case 'Q': // quit
 186                 Serial.println("quit");
 187                 return;
 188
 189             case 'I': // Initialize interface
 190                 Initialize();
 191                 break;
 192
 193             case 'S': // start listening server
 194                 StartListeningServer();
 195                 break;
 196
 197             case 'D': // start discovery server
 198                 StartDiscoveryServer();
 199                 break;
 200
 201             case 'R': // send request
 202                 SendRequest();
 203                 break;
 204
 205             case 'E': //send request to all
 206                 SendRequestAll();
 207                 break;
 208             case 'B': // send notification
 209                 SendNotification();
 210                 break;
 211             case 'G': // Get network info
 212                 GetNetworkInfo();
 213                 break;
 214
 215             case 'N': // select network
 216                 SelectNetwork();
 217                 break;
 218
 219             case 'X': // unselect network
 220                 UnselectNetwork();
 221                 break;
 222
 223             case 'H': // handle request response
 224                 HandleRequestResponse();
 225                 break;
 226
 227             case 'T': // handle request response
 228                 Terminate();
 229                 break;
 230
 231             default:
 232                 Serial.println("wrong menu");
 233                 break;
 234         }
 235     }
 236     //1:Add check for startserver before calling below api
 237     if (g_isLeSelected)
 238     {
 239         HandleRequestResponse();
 240     }
 241     delay(1000);
 242 }
 243
 244 void Initialize()
 245 {
 246     if(CAInitialize() != CA_STATUS_OK)
 247     {
 248         Serial.println("Initialize failed");
 249         return;
 250     }
 251     SelectNetwork();
 252     // set handler.
 253     CARegisterHandler(RequestHandler, ResponseHandler, ErrorHandler);
 254 }
 255
 256 void StartListeningServer()
 257 {
 258     Serial.println("listening server");
 259     CAResult_t ret = CAStartListeningServer();
 260     if(ret != CA_STATUS_OK)
 261     {
 262         Serial.print("listening failed: ");
 263         Serial.println(ret);
 264         return;
 265     }
 266 }
 267
 268 void StartDiscoveryServer()
 269 {
 270     Serial.println("discovery server");
 271     CAResult_t ret = CAStartDiscoveryServer();
 272     if(ret != CA_STATUS_OK)
 273     {
 274         Serial.print("discovery failed: ");
 275         Serial.println(ret);
 276         return;
 277     }
 278 }
 279
 280 void SendRequest()
 281 {
 282     char buf[MAX_BUF_LEN] = {0};
 283     char address[MAX_BUF_LEN] = {0};
 284     char resourceUri[MAX_BUF_LEN] = {0};
 285     char port[PORT_LENGTH] = {0};
 286     CATransportAdapter_t selectedNetwork;
 287     selectedNetwork = GetConnectivityType();
 288
 289     Serial.println("============");
 290     Serial.println("10.11.12.13:4545/res_uri (for IP)");
 291     Serial.println("10:11:12:13:45:45/res_uri (for BT)");
 292     Serial.println("uri: ");
 293
 294     size_t len = 0;
 295     GetData(buf, sizeof(buf), &len);
 296     if (0 >= len)
 297     {
 298         Serial.println("i/p err");
 299         return;
 300     }
 301
 302     if (!ParseData(buf, address, port, resourceUri))
 303     {
 304         Serial.println("bad uri");
 305         return;
 306     }
 307
 308     // create remote endpoint
 309     CAEndpoint_t *endpoint = NULL;
 310     CAResult_t res = CACreateEndpoint(CA_DEFAULT_FLAGS, selectedNetwork, address, atoi(port),
 311                                       &endpoint);
 312     if (res != CA_STATUS_OK)
 313     {
 314         Serial.println("Out of memory");
 315         CADestroyEndpoint(endpoint);
 316         return;
 317     }
 318
 319     memset(buf, 0, sizeof(buf));
 320
 321     Serial.println("\n=============================================\n");
 322     Serial.println("0:CON, 1:NON\n");
 323     Serial.println("select message type : ");
 324     GetData(buf, sizeof(buf), &len);
 325     CAMessageType_t msgType = CA_MSG_CONFIRM;
 326
 327     if (0 >= len)
 328     {
 329         Serial.println("i/p err,default: 0");
 330     }
 331     else if(buf[0] == '1')
 332     {
 333         msgType = CA_MSG_NONCONFIRM;
 334     }
 335
 336     // create token
 337     CAToken_t token = NULL;
 338     uint8_t tokenLength = CA_MAX_TOKEN_LEN;
 339
 340     res = CAGenerateToken(&token, tokenLength);
 341     if (res != CA_STATUS_OK || (!token))
 342     {
 343         Serial.println("token error");
 344         return;
 345     }
 346
 347     Serial.println(token);
 348     CAInfo_t requestData = {CA_MSG_RESET};
 349     requestData.token = token;
 350     requestData.tokenLength = tokenLength;
 351     requestData.payload = (CAPayload_t)"Json Payload";
 352
 353     requestData.type = msgType;
 354     requestData.resourceUri = (char *)OICMalloc(strlen(resourceUri) + 1);
 355     strcpy(requestData.resourceUri, resourceUri);
 356
 357     CARequestInfo_t requestInfo = {CA_GET, {CA_MSG_RESET}};
 358     requestInfo.method = CA_GET;
 359     requestInfo.isMulticast = false;
 360     requestInfo.info = requestData;
 361     requestInfo.isMulticast = false;
 362
 363     // send request
 364     CASendRequest(endpoint, &requestInfo);
 365     if (NULL != token)
 366     {
 367         CADestroyToken(token);
 368     }
 369
 370     // destroy remote endpoint
 371     if (endpoint != NULL)
 372     {
 373         CADestroyEndpoint(endpoint);
 374     }
 375
 376     Serial.println("============");
 377 }
 378
 379 void SendRequestAll()
 380 {
 381     char buf[MAX_BUF_LEN] = {0};
 382     char address[MAX_BUF_LEN] = {0};
 383     char resourceUri[MAX_BUF_LEN] = {0};
 384     char port[PORT_LENGTH] = {0};
 385
 386     CATransportAdapter_t selectedNetwork;
 387     selectedNetwork = GetConnectivityType();
 388
 389     Serial.println("\n=============================================\n");
 390     Serial.println("ex) /a/light\n");
 391     Serial.println("resource uri : ");
 392
 393     size_t len = 0;
 394     GetData(buf, sizeof(buf), &len);
 395     if (0 >= len)
 396     {
 397         Serial.println("i/p err");
 398         return;
 399     }
 400
 401     if (!ParseData(buf, address, port, resourceUri))
 402     {
 403         Serial.println("bad uri");
 404         return;
 405     }
 406
 407     // create remote endpoint
 408     CAEndpoint_t *endpoint = NULL;
 409     CAResult_t res = CACreateEndpoint(CA_DEFAULT_FLAGS, selectedNetwork, address, atoi(port),
 410                                         &endpoint);
 411
 412     if (res != CA_STATUS_OK)
 413     {
 414         Serial.println("create remote endpoint error");
 415         CADestroyEndpoint(endpoint);
 416         return;
 417     }
 418
 419     // create token
 420     CAToken_t token = NULL;
 421     uint8_t tokenLength = CA_MAX_TOKEN_LEN;
 422
 423     res = CAGenerateToken(&token, tokenLength);
 424     if (res != CA_STATUS_OK || (!token))
 425     {
 426         Serial.println("token error");
 427         return;
 428     }
 429
 430     Serial.println(token);
 431
 432     CAInfo_t requestData = {CA_MSG_RESET};
 433     requestData.token = token;
 434     requestData.tokenLength = tokenLength;
 435     requestData.payload = "Temp Json Payload";
 436     requestData.type = CA_MSG_NONCONFIRM;
 437     requestData.resourceUri = (char *)OICMalloc(strlen(resourceUri) + 1);
 438     strcpy(requestData.resourceUri, resourceUri);
 439
 440     CARequestInfo_t requestInfo = {CA_GET, {CA_MSG_RESET}};
 441     requestInfo.method = CA_GET;
 442     requestInfo.isMulticast = true;
 443     requestInfo.info = requestData;
 444
 445     // send request
 446     CASendRequest(endpoint, &requestInfo);
 447
 448     if (NULL != token)
 449     {
 450         CADestroyToken(token);
 451     }
 452
 453     // destroy remote endpoint
 454     if (endpoint != NULL)
 455     {
 456         CADestroyEndpoint(endpoint);
 457     }
 458
 459     Serial.println("==========");
 460 }
 461
 462 void SendNotification()
 463 {
 464     char buf[MAX_BUF_LEN] = {0};
 465     char address[MAX_BUF_LEN] = {0};
 466     char resourceUri[MAX_BUF_LEN] = {0};
 467     char port[PORT_LENGTH] = {0};
 468     CATransportAdapter_t selectedNetwork;
 469     selectedNetwork = GetConnectivityType();
 470
 471     Serial.println("============");
 472     Serial.println("10.11.12.13:4545/res_uri (for IP)");
 473     Serial.println("10:11:12:13:45:45/res_uri (for BT)");
 474     Serial.println("uri: ");
 475
 476     size_t len = 0;
 477     GetData(buf, sizeof(buf), &len);
 478     if (0 >= len)
 479     {
 480         Serial.println("i/p err");
 481         return;
 482     }
 483
 484     if (!ParseData(buf, address, port, resourceUri))
 485     {
 486         Serial.println("bad uri");
 487         return;
 488     }
 489
 490     // create remote endpoint
 491     CAEndpoint_t *endpoint = NULL;
 492     CAResult_t res = CACreateEndpoint(CA_DEFAULT_FLAGS, selectedNetwork, address, atoi(port),
 493                                       &endpoint);
 494     if (CA_STATUS_OK != res)
 495     {
 496         Serial.println("Out of memory");
 497         CADestroyEndpoint(endpoint);
 498         return;
 499     }
 500
 501     // create token
 502     CAToken_t token = NULL;
 503     uint8_t tokenLength = CA_MAX_TOKEN_LEN;
 504
 505     res = CAGenerateToken(&token, tokenLength);
 506     if (res != CA_STATUS_OK || (!token))
 507     {
 508         Serial.println("token error");
 509         return;
 510     }
 511
 512     CAInfo_t respondData = {CA_MSG_NONCONFIRM};
 513     respondData.token = token;
 514     respondData.tokenLength = tokenLength;
 515     respondData.payload = (CAPayload_t)"Notification Data";
 516     respondData.resourceUri = (char *)OICMalloc(strlen(resourceUri) + 1);
 517     strcpy(respondData.resourceUri, resourceUri);
 518
 519     CAResponseInfo_t responseInfo = {CA_BAD_REQ, {CA_MSG_RESET}};
 520     responseInfo.result = CA_CONTENT;
 521     responseInfo.info = respondData;
 522
 523     // send request
 524     CASendNotification(endpoint, &responseInfo);
 525     // destroy remote endpoint
 526     if (NULL != endpoint)
 527     {
 528         CADestroyEndpoint(endpoint);
 529     }
 530
 531     CADestroyToken(token);
 532     Serial.println("============");
 533 }
 534
 535 void SelectNetwork()
 536 {
 537     char buf[MAX_BUF_LEN] = {0};
 538
 539     Serial.println("============");
 540     Serial.println("Select network");
 541     Serial.println("IP: 0");
 542     Serial.println("LE: 1");
 543     Serial.println("EDR: 2\n");
 544
 545     size_t len = 0;
 546     GetData(buf, sizeof(buf), &len);
 547     int number = buf[0] - '0';
 548     if (0 >= len || number < 0 || number > 3)
 549     {
 550         Serial.println("Wrong i/p. WIFI selected");
 551         number = 1;
 552     }
 553
 554     switch (number)
 555     {
 556         case 0:
 557             {
 558 #ifdef ARDUINOWIFI
 559                 const char ssid[] = "SSID";              // your network SSID (name)
 560                 const char pass[] = "SSID_Password";     // your network password
 561                 int16_t status = WL_IDLE_STATUS;         // the Wifi radio's status
 562
 563                 if (WiFi.status() == WL_NO_SHIELD)
 564                 {
 565                     Serial.println("ERROR:No Shield");
 566                     return;
 567                 }
 568
 569                 while (status != WL_CONNECTED)
 570                 {
 571                     Serial.print("connecting: ");
 572                     Serial.println(ssid);
 573                     // WiFi.begin api is weird. ssid should also be taken as const char *
 574                     // Connect to WPA/WPA2 network:
 575                     status = WiFi.begin((char *)ssid, pass);
 576                 }
 577 #elif defined ARDUINOETH
 578                 // Note: ****Update the MAC address here with your shield's MAC address****
 579                 uint8_t ETHERNET_MAC[] = {0x90, 0xA2, 0xDA, 0x0E, 0xC4, 0x05};
 580                 uint8_t error = Ethernet.begin(ETHERNET_MAC);
 581                 if (error  == 0)
 582                 {
 583                     Serial.print("Failed: ");
 584                     Serial.println(error);
 585                     return;
 586                 }
 587 #endif
 588             }
 589             break;
 590         case 1:
 591             g_isLeSelected = true;
 592             break;
 593         case 2:
 594             // Nothing TBD here
 595             break;
 596     }
 597
 598     CASelectNetwork(CATransportAdapter_t(1<<number));
 599     Serial.println("============");
 600 }
 601
 602 void UnselectNetwork()
 603 {
 604     char buf[MAX_BUF_LEN] = {0};
 605
 606     Serial.println("============");
 607     Serial.println("Unselect network");
 608     Serial.println("IPv4: 0");
 609     Serial.println("LE: 1");
 610     Serial.println("EDR: 2\n");
 611
 612     size_t len = 0;
 613     GetData(buf, sizeof(buf), &len);
 614     int number = buf[0] - '0';
 615     Serial.println(number);
 616     if (0 >= len || number < 0 || number > 3)
 617     {
 618         Serial.println("Wrong i/p. WIFI selected");
 619         number = 1;
 620     }
 621     if (number == 3)
 622     {
 623         g_isLeSelected = false;
 624     }
 625     CAUnSelectNetwork(1 << number);
 626     Serial.println("Terminate");
 627     CATerminate();
 628     Serial.println("============");
 629 }
 630
 631 void GetNetworkInfo()
 632 {
 633     CAEndpoint_t *tempInfo = NULL;
 634     uint32_t tempSize = 0;
 635     CAResult_t res = CAGetNetworkInformation(&tempInfo, &tempSize);
 636     if (CA_STATUS_OK != res || NULL == tempInfo || 0 >= tempSize)
 637     {
 638         Serial.println("Network not connected");
 639         free(tempInfo);
 640         return;
 641     }
 642     printf("=========");
 643     printf("Network info total size is %d\n\n", tempSize);
 644     int index;
 645     for (index = 0; index < tempSize; index++)
 646     {
 647         Serial.println("Type:");
 648         Serial.println(tempInfo[index].adapter);
 649         if (CA_ADAPTER_IP == tempInfo[index].adapter)
 650         {
 651             Serial.println("Address:");
 652             Serial.println(tempInfo[index].addr);
 653             Serial.println("Port:");
 654             Serial.println(tempInfo[index].port);
 655         }
 656     }
 657     free(tempInfo);
 658     Serial.println("=======");
 659 }
 660
 661 void PrintMenu()
 662 {
 663
 664     Serial.println("============");
 665     Serial.println("i: Initialize");
 666     Serial.println("s: start listening server");
 667     Serial.println("d: start discovery server");
 668     Serial.println("r: send request");
 669     Serial.println("e: send request to all");
 670     Serial.println("b: send notification");
 671     Serial.println("g: get network info");
 672     Serial.println("n: select network");
 673     Serial.println("x: unselect network");
 674     Serial.println("h: handle request response");
 675     Serial.println("t: terminate");
 676     Serial.println("q: quit");
 677     Serial.println("============");
 678 }
 679
 680 void HandleRequestResponse()
 681 {
 682     CAHandleRequestResponse();
 683 }
 684
 685 void RequestHandler(const CAEndpoint_t *object, const CARequestInfo_t *requestInfo)
 686 {
 687     if (!object)
 688     {
 689         Serial.println("endpoint is NULL!");
 690         return;
 691     }
 692
 693     if (!requestInfo)
 694     {
 695         Serial.println("Request info is NULL!");
 696         return;
 697     }
 698
 699     Serial.println("RAddr: ");
 700     Serial.println(object->addr);
 701     Serial.println("Port: ");
 702     Serial.println(object->port);
 703     Serial.println("uri: ");
 704     Serial.println(requestInfo->info.resourceUri);
 705     Serial.println("data: ");
 706     Serial.println(requestInfo->info.payload);
 707     Serial.println("Type: ");
 708     Serial.println(requestInfo->info.type);
 709
 710     if (requestInfo->info.options)
 711     {
 712         uint32_t len = requestInfo->info.numOptions;
 713         uint32_t i;
 714         for (i = 0; i < len; i++)
 715         {
 716             Serial.println("Option:");
 717             Serial.println(i+1);
 718             Serial.println("ID:");
 719             Serial.println(requestInfo->info.options[i].optionID);
 720             Serial.println("Data:");
 721             Serial.println((char*)requestInfo->info.options[i].optionData);
 722         }
 723     }
 724     Serial.println("send response");
 725     SendResponse((CAEndpoint_t *)object, (requestInfo != NULL) ? &requestInfo->info : NULL);
 726 }
 727
 728 void ResponseHandler(const CAEndpoint_t *object, const CAResponseInfo_t *responseInfo)
 729 {
 730     if (object)
 731     {
 732         Serial.print("uri: ");
 733         Serial.println(object->addr);
 734     }
 735
 736     if (responseInfo)
 737     {
 738         Serial.print("uri: ");
 739         Serial.println(responseInfo->info.resourceUri);
 740         Serial.print("data: ");
 741         Serial.println(responseInfo->info.payload);
 742         Serial.print("Type: ");
 743         Serial.println(responseInfo->info.type);
 744         Serial.print("res result=");
 745         Serial.println(responseInfo->result);
 746     }
 747 }
 748
 749 void ErrorHandler(const CAEndpoint_t *rep, const CAErrorInfo_t* errorInfo)
 750 {
 751     printf("+++++++++++++++++++++++++++++++++++ErrorInfo+++++++++++++++++++++++++++++++++++\n");
 752
 753     if(errorInfo)
 754     {
 755         const CAInfo_t *info = &errorInfo->info;
 756         printf("Error Handler, ErrorInfo :\n");
 757         printf("Error Handler result    : %d\n", errorInfo->result);
 758         printf("Error Handler token     : %s\n", info->token);
 759         printf("Error Handler messageId : %d\n", (uint16_t) info->messageId);
 760         printf("Error Handler type      : %d\n", info->type);
 761         printf("Error Handler resourceUri : %s\n", info->resourceUri);
 762         printf("Error Handler payload   : %s\n", info->payload);
 763
 764         if(CA_ADAPTER_NOT_ENABLED == errorInfo->result)
 765         {
 766             printf("CA_ADAPTER_NOT_ENABLED, enable the adapter\n");
 767         }
 768         else if(CA_SEND_FAILED == errorInfo->result)
 769         {
 770             printf("CA_SEND_FAILED, unable to send the message, check parameters\n");
 771         }
 772         else if(CA_MEMORY_ALLOC_FAILED == errorInfo->result)
 773         {
 774             printf("CA_MEMORY_ALLOC_FAILED, insufficient memory\n");
 775         }
 776         else if(CA_SOCKET_OPERATION_FAILED == errorInfo->result)
 777         {
 778             printf("CA_SOCKET_OPERATION_FAILED, socket operation failed\n");
 779         }
 780         else if(CA_STATUS_FAILED == errorInfo->result)
 781         {
 782             printf("CA_STATUS_FAILED, message could not be delivered, internal error\n");
 783         }
 784     }
 785     printf("++++++++++++++++++++++++++++++++End of ErrorInfo++++++++++++++++++++++++++++++++\n");
 786
 787     return;
 788 }
 789
 790 void SendResponse(CAEndpoint_t *endpoint, const CAInfo_t* info)
 791 {
 792     char buf[MAX_BUF_LEN] = {0};
 793
 794     Serial.println("============");
 795     Serial.println("Select Message Type");
 796     Serial.println("CON: 0");
 797     Serial.println("NON: 1");
 798     Serial.println("ACK: 2");
 799     Serial.println("RESET: 3");
 800
 801     size_t len = 0;
 802     int messageType = 0;
 803     while(1)
 804     {
 805         GetData(buf, sizeof(buf), &len);
 806         if(len >= 1)
 807         {
 808             messageType = buf[0] - '0';
 809             if (messageType >= 0 && messageType <= 3)
 810             {
 811                 break;
 812             }
 813         }
 814         Serial.println("Invalid type");
 815     }
 816
 817     int respCode = 0;
 818     if(messageType != 3)
 819     {
 820         Serial.println("============");
 821         Serial.println("Enter Resp Code:");
 822         Serial.println("For Ex: Empty  : 0");
 823         Serial.println("Success: 200");
 824         Serial.println("Created: 201");
 825         Serial.println("Deleted: 202");
 826         Serial.println("Valid  : 203");
 827         Serial.println("Changed: 204");
 828         Serial.println("Content: 205");
 829         Serial.println("BadReq : 400");
 830         Serial.println("BadOpt : 402");
 831         Serial.println("NotFnd : 404");
 832         Serial.println("Internal Srv Err:500");
 833         Serial.println("Timeout: 504");
 834         while(1)
 835         {
 836             GetData(buf, sizeof(buf), &len);
 837             if(len >= 1)
 838             {
 839                 respCode = atoi(buf);
 840                 if (respCode >= 0 && respCode <= 504)
 841                 {
 842                     break;
 843                 }
 844             }
 845             Serial.println("Invalid response");
 846         }
 847     }
 848
 849     CAInfo_t responseData = {CA_MSG_RESET};
 850     responseData.type = static_cast<CAMessageType_t>(messageType);
 851     responseData.messageId = (info != NULL) ? info->messageId : 0;
 852     responseData.resourceUri = (info != NULL) ? info->resourceUri : 0;
 853     if(messageType != 3)
 854     {
 855         responseData.token = (info != NULL) ? info->token : NULL;
 856         responseData.tokenLength = (info != NULL) ? info->tokenLength : 0;
 857         responseData.payload = static_cast<CAPayload_t>("response payload");
 858     }
 859     CAResponseInfo_t responseInfo = {CA_BAD_REQ, {CA_MSG_RESET}};
 860     responseInfo.result = static_cast<CAResponseResult_t>(respCode);
 861     responseInfo.info = responseData;
 862     // send request (transportType from remoteEndpoint of request Info)
 863     CAResult_t res = CASendResponse(endpoint, &responseInfo);
 864     if(res != CA_STATUS_OK)
 865     {
 866         Serial.println("Snd Resp error");
 867     }
 868     else
 869     {
 870         Serial.println("Snd Resp success");
 871     }
 872
 873     Serial.println("============");
 874 }
 875
 876 void Terminate()
 877 {
 878     UnselectNetwork();
 879 }
 880