service/easy-setup/enrollee/src/samsung/sc_easysetup.c

   1 //******************************************************************
   2 //
   3 // Copyright 2015 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
  22 #include "samsung/sc_easysetup.h"
  23 #include "string.h"
  24 #include "oic_malloc.h"
  25 #include "logger.h"
  26 #include "stdio.h"
  27
  28 #include "ocpayload.h"
  29 #include "oic_string.h"
  30 #include "oic_malloc.h"
  31
  32 #include "resourcehandler.h"
  33
  34 /**
  35  * @var SC_ENROLLEE_TAG
  36  * @brief Logging tag for module name.
  37  */
  38 #define SC_ENROLLEE_TAG "ES_SC_ENROLLEE"
  39
  40 SCProperties g_SCProperties;
  41
  42 static void ReadAccountData(OCRepPayload* payload,void** userdata);
  43 static void ReadTnCdata(OCRepPayload* payload,void** userdata);
  44 static void WriteTnCdata(OCRepPayload* payload, char* resourceType);
  45 static void WriteWifiData(OCRepPayload* payload, char* resourceType);
  46
  47 ESResult SetSCProperties(const SCProperties *prop)
  48 {
  49     OIC_LOG(INFO, SC_ENROLLEE_TAG, "SetSCProperties IN");
  50     if(prop != NULL)
  51     {
  52         memcpy(&g_SCProperties, prop, sizeof(SCProperties));
  53         OIC_LOG(INFO, SC_ENROLLEE_TAG, "SetSCProperties OUT");
  54         return ES_OK;
  55     }
  56     OIC_LOG(INFO, SC_ENROLLEE_TAG, "SetSCProperties OUT");
  57     return ES_ERROR;
  58 }
  59
  60 static void ReadAccountData(OCRepPayload* payload,void** userdata)
  61 {
  62     OIC_LOG(INFO, SC_ENROLLEE_TAG, "ReadAccountData IN");
  63
  64     char* account = NULL;
  65
  66     if(OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_ACCOUNT, &account))
  67     {
  68         if(*userdata == NULL)
  69         {
  70             *userdata = (void*)OICMalloc(sizeof(SCDevConfProperties));
  71             if( *userdata == NULL )
  72             {
  73                 OIC_LOG(ERROR, SC_ENROLLEE_TAG, "OICMalloc for SCDevConfProperties is failed");
  74                 OICFree(account);
  75                 return;
  76             }
  77         }
  78
  79         SCDevConfProperties *pDevConfProp = (SCDevConfProperties*)(*userdata);
  80         OICStrcpy(pDevConfProp->account, MAXLEN_STRING, account);
  81         OICStrcpy(g_SCProperties.account, MAXLEN_STRING, account);
  82
  83         OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %s",
  84                 SC_RSRVD_ES_VENDOR_ACCOUNT, pDevConfProp->account);
  85
  86         OICFree(account);
  87     }
  88     OIC_LOG(INFO, SC_ENROLLEE_TAG, "ReadAccountData OUT");
  89
  90 }
  91
  92 ESResult SetSCTncInfo(SCTncInfo *tncInfo)
  93 {
  94     if(tncInfo == NULL)
  95     {
  96         return ES_ERROR;
  97     }
  98     g_SCProperties.tncInfo = *tncInfo;
  99     return ES_OK;
 100 }
 101
 102 ESResult SetSCTncStatus(int status)
 103 {
 104     g_SCProperties.tncStatus = status;
 105     return ES_OK;
 106 }
 107
 108 ESResult SetSCNetConnectionState(NETCONNECTION_STATE netConnectionState)
 109 {
 110     OIC_LOG(INFO, SC_ENROLLEE_TAG, "SetSCNetConnectionState IN");
 111
 112     OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "SetSCNetConnectionState: %d", netConnectionState);
 113     g_SCProperties.netConnectionState = netConnectionState;
 114
 115     if(OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESEasySetupResource.handle, OC_HIGH_QOS))
 116     {
 117         OIC_LOG(DEBUG, SC_ENROLLEE_TAG, "provResource doesn't have any observers.");
 118     }
 119
 120     OIC_LOG(INFO, SC_ENROLLEE_TAG, "SetSCNetConnectionState OUT");
 121     return ES_OK;
 122 }
 123
 124 static void ReadTnCdata(OCRepPayload* payload,void** userdata)
 125 {
 126     OIC_LOG(INFO, SC_ENROLLEE_TAG, "ReadTnCdata IN");
 127
 128     char* tncResult = NULL;
 129
 130     if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_TNC_RESULT, &tncResult))
 131     {
 132         if(*userdata == NULL)
 133         {
 134             *userdata = (void*)OICMalloc(sizeof(SCCoapCloudServerConfProperties));
 135             if( *userdata == NULL )
 136             {
 137                 OIC_LOG(ERROR, SC_ENROLLEE_TAG, "OICMalloc for SCCoapCloudServerConfProperties is failed");
 138                 return ;
 139             }
 140         }
 141
 142         SCCoapCloudServerConfProperties *pProp = (SCCoapCloudServerConfProperties*)(*userdata);
 143         OICStrcpy(pProp->tncResult, MAXLEN_STRING, tncResult);
 144         OICStrcpy(g_SCProperties.tncResult, MAXLEN_STRING, tncResult);
 145
 146         OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %s",
 147                 SC_RSRVD_ES_VENDOR_TNC_RESULT, pProp->tncResult);
 148     }
 149
 150     OIC_LOG(INFO, SC_ENROLLEE_TAG, "ReadTnCdata OUT");
 151 }
 152
 153 void WriteTnCdata(OCRepPayload* payload, char* resourceType)
 154 {
 155     OIC_LOG(INFO, SC_ENROLLEE_TAG, "WriteTnCdata IN");
 156
 157     if(payload == NULL || resourceType == NULL)
 158     {
 159         OIC_LOG(DEBUG, SC_ENROLLEE_TAG, "Invalid Params payload or resourceType is NULL");
 160         OIC_LOG(DEBUG, SC_ENROLLEE_TAG, "WriteTnCdata OUT");
 161         return;
 162     }
 163     if(strstr(resourceType, OC_RSRVD_ES_RES_TYPE_EASYSETUP))
 164     {
 165         OCRepPayloadSetPropInt(payload, SC_RSRVD_ES_VENDOR_TNC_STATUS, g_SCProperties.tncStatus);
 166     }
 167     else if(strstr(resourceType, OC_RSRVD_ES_RES_TYPE_DEVCONF))
 168     {
 169         OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_TNC_HEADER,
 170                 g_SCProperties.tncInfo.header);
 171         OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_TNC_VERSION,
 172                 g_SCProperties.tncInfo.version);
 173     }
 174     else if(strstr(resourceType, OC_RSRVD_ES_RES_TYPE_COAPCLOUDCONF))
 175     {
 176         OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_TNC_RESULT,
 177                 g_SCProperties.tncResult);
 178     }
 179     OIC_LOG(INFO, SC_ENROLLEE_TAG, "WriteTnCdata OUT");
 180 }
 181
 182 void WriteWifiData(OCRepPayload* payload, char* resourceType)
 183 {
 184     OIC_LOG(INFO, SC_ENROLLEE_TAG, "WriteWifiData IN");
 185
 186     if(payload == NULL || resourceType == NULL)
 187     {
 188         OIC_LOG(DEBUG, SC_ENROLLEE_TAG, "Invalid Params payload or resourceType is NULL");
 189         OIC_LOG(DEBUG, SC_ENROLLEE_TAG, "WriteWifiData OUT");
 190         return;
 191     }
 192
 193     if(strstr(resourceType, OC_RSRVD_ES_RES_TYPE_WIFICONF))
 194     {
 195         OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_BSSID,
 196                 g_SCProperties.bssid);
 197     }
 198     OIC_LOG(INFO, SC_ENROLLEE_TAG, "WriteWifiData OUT");
 199 }
 200
 201 ESResult SetRegisterSetDevice(const char *regSetDevice)
 202 {
 203     if(regSetDevice != NULL)
 204     {
 205         OICStrcpy(g_SCProperties.regSetDev, sizeof(g_SCProperties.regSetDev), regSetDevice);
 206         return ES_OK;
 207     }
 208     return ES_ERROR;
 209 }
 210
 211 ESResult SetNetworkProvInfo(const char *nwProvInfo)
 212 {
 213     if(nwProvInfo != NULL)
 214     {
 215         OICStrcpy(g_SCProperties.nwProvInfo, sizeof(g_SCProperties.nwProvInfo), nwProvInfo);
 216         return ES_OK;
 217     }
 218     return ES_ERROR;
 219 }
 220
 221 ESResult SetSCPnPPin(const char *pnp)
 222 {
 223     if(pnp != NULL)
 224     {
 225         OICStrcpy(g_SCProperties.pnpPin, sizeof(g_SCProperties.pnpPin), pnp);
 226         return ES_OK;
 227     }
 228     return ES_ERROR;
 229 }
 230
 231 ESResult SetESVersionInfo(const char *esProtocolVersion)
 232 {
 233     if(esProtocolVersion != NULL)
 234     {
 235         OICStrcpy(g_SCProperties.esProtocolVersion, sizeof(g_SCProperties.esProtocolVersion), esProtocolVersion);
 236         return ES_OK;
 237     }
 238     return ES_ERROR;
 239 }
 240
 241 void ReadUserdataCb(OCRepPayload* payload, char* resourceType, void** userdata)
 242 {
 243     OIC_LOG(INFO, SC_ENROLLEE_TAG, "ReadUserdataCb IN");
 244
 245     if(payload != NULL)
 246     {
 247         if(strstr(resourceType, OC_RSRVD_ES_RES_TYPE_WIFICONF))
 248         {
 249             int64_t channel = -1;
 250             char *bssid = NULL;
 251             if (OCRepPayloadGetPropInt(payload, SC_RSRVD_ES_VENDOR_DISCOVERY_CHANNEL, &channel))
 252             {
 253                 if(*userdata == NULL)
 254                 {
 255                     *userdata = (void*)OICMalloc(sizeof(SCWiFiConfProperties));
 256                     if( *userdata == NULL )
 257                     {
 258                         OIC_LOG(ERROR, SC_ENROLLEE_TAG, "OICMalloc for SCWiFiConfProperties is failed");
 259                         return ;
 260                     }
 261                     memset(*userdata, 0, sizeof(SCWiFiConfProperties));
 262                 }
 263                 OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : [%" PRId64 "]",
 264                                                             SC_RSRVD_ES_VENDOR_DISCOVERY_CHANNEL, channel);
 265                 ((SCWiFiConfProperties*)(*userdata))->discoveryChannel = (int) channel;
 266                 g_SCProperties.discoveryChannel = channel;
 267             }
 268             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_BSSID, &bssid))
 269             {
 270                 if(*userdata == NULL)
 271                 {
 272                     *userdata = (void*) OICMalloc(sizeof(SCWiFiConfProperties));
 273                     if( *userdata == NULL )
 274                     {
 275                         OIC_LOG(ERROR, SC_ENROLLEE_TAG, "OICMalloc for SCWiFiConfProperties is failed");
 276                         return ;
 277                     }
 278                     memset(*userdata, 0, sizeof(SCWiFiConfProperties));
 279                 }
 280                 if (*userdata != NULL)
 281                 {
 282                     OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %s",
 283                             SC_RSRVD_ES_VENDOR_BSSID, bssid);
 284                     SCWiFiConfProperties* pWifiConfProp = (SCWiFiConfProperties*)(*userdata);
 285                     OICStrcpy(pWifiConfProp->bssid, sizeof(pWifiConfProp->bssid), bssid);
 286                     OICStrcpy(g_SCProperties.bssid, sizeof(g_SCProperties.bssid), bssid);
 287                     OICFree(bssid);
 288                 }
 289             }
 290
 291             OCRepPayload **repPayload = NULL;
 292             size_t dimensions[MAX_REP_ARRAY_DEPTH];
 293             if(OCRepPayloadGetPropObjectArray(payload, SC_RSRVD_ES_VENDOR_CANDIDATEAPS, &repPayload, dimensions))
 294             {
 295                 if(*userdata == NULL)
 296                 {
 297                     *userdata = (void*) OICMalloc(sizeof(SCWiFiConfProperties));
 298                     if( *userdata == NULL )
 299                     {
 300                         OIC_LOG(ERROR, SC_ENROLLEE_TAG, "OICMalloc for SCWiFiConfProperties is failed");
 301                         return ;
 302                     }
 303                     memset(*userdata, 0, sizeof(SCWiFiConfProperties));
 304                 }
 305                 //size_t dim = calcDimTotal(dimensions);
 306                 SCWiFiConfProperties* pWifiConfProp = (SCWiFiConfProperties*)(*userdata);
 307                 for (size_t i = 0; i < dimensions[0]; i++)
 308                 {
 309                    int64_t cd_channel = -1;
 310                    char *cd_bssid = NULL;
 311                    char *ssid = NULL;
 312                    char *pwd = NULL;
 313                    if (OCRepPayloadGetPropString(repPayload[i], SC_RSRVD_ES_VENDOR_SSID, &ssid))
 314                    {
 315                        OICStrcpy(pWifiConfProp->candidateAPInfo[i].ssid, sizeof(pWifiConfProp->candidateAPInfo[i].ssid), ssid);
 316                        OICStrcpy(g_SCProperties.candidateAPInfo[i].ssid, sizeof(g_SCProperties.candidateAPInfo[i].ssid), ssid);
 317                        OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %s",
 318                             SC_RSRVD_ES_VENDOR_SSID, ssid);
 319                        OICFree(ssid);
 320                    }
 321                    if (OCRepPayloadGetPropString(repPayload[i], SC_RSRVD_ES_VENDOR_PASSPHRASE, &pwd))
 322                    {
 323                        OICStrcpy(pWifiConfProp->candidateAPInfo[i].passphrase, sizeof(pWifiConfProp->candidateAPInfo[i].passphrase), pwd);
 324                        OICStrcpy(g_SCProperties.candidateAPInfo[i].passphrase, sizeof(g_SCProperties.candidateAPInfo[i].passphrase), pwd);
 325                                               OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %s",
 326                             SC_RSRVD_ES_VENDOR_PASSPHRASE, ssid);
 327                        OICFree(pwd);
 328                    }
 329                    if (OCRepPayloadGetPropInt(repPayload[i], SC_RSRVD_ES_VENDOR_CANDIDATE_CHANNEL, &cd_channel))
 330                    {
 331                        pWifiConfProp->candidateAPInfo[i].channel = (int) cd_channel;
 332                        g_SCProperties.candidateAPInfo[i].channel = cd_channel;
 333                                               OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %d",
 334                             SC_RSRVD_ES_VENDOR_CANDIDATE_CHANNEL, cd_channel);
 335                    }
 336                    if (OCRepPayloadGetPropString(repPayload[i], SC_RSRVD_ES_VENDOR_BSSID, &cd_bssid))
 337                    {
 338                        OICStrcpy(pWifiConfProp->candidateAPInfo[i].bssid, sizeof(pWifiConfProp->candidateAPInfo[i].bssid), cd_bssid);
 339                        OICStrcpy(g_SCProperties.candidateAPInfo[i].bssid, sizeof(g_SCProperties.candidateAPInfo[i].bssid), cd_bssid);
 340                                               OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %s",
 341                             SC_RSRVD_ES_VENDOR_BSSID, cd_bssid);
 342                        OICFree(bssid);
 343                    }
 344                 }
 345                 pWifiConfProp->numCandidateAP = (int)dimensions[0];
 346                 g_SCProperties.numCandidateAP = (int)dimensions[0];
 347             }
 348         }
 349         else if(strstr(resourceType, OC_RSRVD_ES_RES_TYPE_DEVCONF))
 350         {
 351             if(*userdata == NULL)
 352             {
 353                 *userdata = (void*)OICMalloc(sizeof(SCDevConfProperties));
 354                 if( *userdata == NULL )
 355                 {
 356                     OIC_LOG(ERROR, SC_ENROLLEE_TAG, "OICMalloc for SCDevConfProperties is failed");
 357                     return ;
 358                 }
 359                 memset(*userdata, 0, sizeof(SCDevConfProperties));
 360             }
 361
 362             SCDevConfProperties *pDevConfProp = (SCDevConfProperties*)(*userdata);
 363
 364             char**locationList = NULL;
 365             size_t dimensions[MAX_REP_ARRAY_DEPTH] = {0};
 366             if(OCRepPayloadGetStringArray(payload, SC_RSRVD_ES_VENDOR_LOCATION, &locationList, dimensions))
 367             {
 368                 for(size_t idx = 0; idx < dimensions[0]; idx++)
 369                 {
 370                     OICStrcpy(pDevConfProp->location[idx], strlen(locationList[idx])+1, locationList[idx]);
 371                     OICStrcpy(g_SCProperties.location[idx], strlen(locationList[idx])+1, locationList[idx]);
 372
 373                     OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %s",
 374                                         SC_RSRVD_ES_VENDOR_LOCATION, pDevConfProp->location[idx]);
 375                 }
 376
 377                 ((SCDevConfProperties*)(*userdata))->numLocation = (int)dimensions[0];
 378                 g_SCProperties.numLocation = (int)dimensions[0];
 379             }
 380
 381             ReadAccountData(payload,userdata);
 382
 383             char *regMobileDev = NULL;
 384             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_REGISTER_MOBILE_DEV, &regMobileDev))
 385             {
 386                 OICStrcpy(pDevConfProp->regMobileDev, strlen(regMobileDev)+1, regMobileDev);
 387                 OICStrcpy(g_SCProperties.regMobileDev, strlen(regMobileDev)+1, regMobileDev);
 388                 OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "pDevConfProp.regMobileDev %s", g_SCProperties.regMobileDev);
 389             }
 390
 391             char *country = NULL;
 392             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_COUNTRY, &country))
 393             {
 394                 OICStrcpy(pDevConfProp->country, strlen(country)+1, country);
 395                 OICStrcpy(g_SCProperties.country, strlen(country)+1, country);
 396                 OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "pDevConfProp.country %s", g_SCProperties.country);
 397             }
 398
 399             char *language = NULL;
 400             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_LANGUAGE, &language))
 401             {
 402                 OICStrcpy(pDevConfProp->language, strlen(language)+1, language);
 403                 OICStrcpy(g_SCProperties.language, strlen(language)+1, language);
 404                 OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "pDevConfProp.language %s", g_SCProperties.language);
 405             }
 406
 407             char *gpsLocation = NULL;
 408             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_GPSLOCATION, &gpsLocation))
 409             {
 410                 OICStrcpy(pDevConfProp->gpsLocation, strlen(gpsLocation)+1, gpsLocation);
 411                 OICStrcpy(g_SCProperties.gpsLocation, strlen(gpsLocation)+1, gpsLocation);
 412                 OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "pDevConfProp.gpsLocation %s", g_SCProperties.gpsLocation);
 413             }
 414
 415             char *utcDateTime = NULL;
 416             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_UTC_DATE_TIME, &utcDateTime))
 417             {
 418                 OICStrcpy(pDevConfProp->utcDateTime, strlen(utcDateTime)+1, utcDateTime);
 419                 OICStrcpy(g_SCProperties.utcDateTime, strlen(utcDateTime)+1, utcDateTime);
 420                 OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "pDevConfProp.utcDateTime %s", g_SCProperties.utcDateTime);
 421             }
 422
 423             char *regionalDateTime = NULL;
 424             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_REGIONAL_DATE_TIME, &regionalDateTime))
 425             {
 426                 OICStrcpy(pDevConfProp->regionalDateTime, strlen(regionalDateTime)+1, regionalDateTime);
 427                 OICStrcpy(g_SCProperties.regionalDateTime, strlen(regionalDateTime)+1, regionalDateTime);
 428                 OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "pDevConfProp.regionalDateTime %s", g_SCProperties.regionalDateTime);
 429             }
 430
 431             char *ssoList = NULL;
 432             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_SSO_LIST, &ssoList))
 433             {
 434                 OICStrcpy(pDevConfProp->ssoList, strlen(ssoList)+1, ssoList);
 435                 OICStrcpy(g_SCProperties.ssoList, strlen(ssoList)+1, ssoList);
 436                 OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "pDevConfProp.ssoList %s", g_SCProperties.ssoList);
 437             }
 438         }
 439         else if(strstr(resourceType, OC_RSRVD_ES_RES_TYPE_COAPCLOUDCONF))
 440         {
 441             char* clientID = NULL;
 442             if(OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_CLIENTID, &clientID))
 443             {
 444                 if(*userdata == NULL)
 445                 {
 446                     *userdata = (void*)OICMalloc(sizeof(SCCoapCloudServerConfProperties));
 447                     if( *userdata == NULL )
 448                     {
 449                         OIC_LOG(ERROR, SC_ENROLLEE_TAG, "OICMalloc for SCCoapCloudServerConfProperties is failed");
 450                         return ;
 451                     }
 452                     memset(*userdata, 0, sizeof(SCCoapCloudServerConfProperties));
 453                 }
 454
 455                 SCCoapCloudServerConfProperties *pCloudProp =
 456                                                     (SCCoapCloudServerConfProperties*)(*userdata);
 457
 458                 OICStrcpy(pCloudProp->clientID, strlen(clientID)+1, clientID);
 459                 OICStrcpy(g_SCProperties.clientID, strlen(clientID)+1, clientID);
 460
 461                 OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %s",
 462                                         SC_RSRVD_ES_VENDOR_CLIENTID, pCloudProp->clientID);
 463             }
 464
 465             //SC_RSRVD_ES_VENDOR_AAC
 466             char *aac = NULL;
 467             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_AAC, &aac))
 468             {
 469                 if(*userdata == NULL)
 470                 {
 471                     *userdata = (void*)OICMalloc(sizeof(SCCoapCloudServerConfProperties));
 472                     if( *userdata == NULL )
 473                     {
 474                         OIC_LOG(ERROR, SC_ENROLLEE_TAG, "OICMalloc for SCCoapCloudServerConfProperties is failed");
 475                         return ;
 476                     }
 477                     memset(*userdata, 0, sizeof(SCCoapCloudServerConfProperties));
 478                 }
 479
 480                 if (*userdata != NULL)
 481                 {
 482                     SCCoapCloudServerConfProperties *pCloudProp =
 483                                                     (SCCoapCloudServerConfProperties*) (*userdata);
 484                     pCloudProp->aac[0] = '\0';
 485
 486                     OICStrcpy(pCloudProp->aac, MAXLEN_STRING, aac);
 487                     OICStrcpy(g_SCProperties.aac, MAXLEN_STRING, aac);
 488                     OICFree(aac);
 489
 490                     OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %s",
 491                             SC_RSRVD_ES_VENDOR_AAC, pCloudProp->aac);
 492                 }
 493             }
 494
 495             //SC_RSRVD_ES_VENDOR_UID
 496             char *uid = NULL;
 497             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_UID, &uid))
 498             {
 499                 if(*userdata == NULL)
 500                 {
 501                     *userdata = (void*)OICMalloc(sizeof(SCCoapCloudServerConfProperties));
 502                     if( *userdata == NULL )
 503                     {
 504                         OIC_LOG(ERROR, SC_ENROLLEE_TAG, "OICMalloc for SCCoapCloudServerConfProperties is failed");
 505                         return ;
 506                     }
 507                     memset(*userdata, 0, sizeof(SCCoapCloudServerConfProperties));
 508                 }
 509
 510                 if (*userdata != NULL)
 511                 {
 512                     SCCoapCloudServerConfProperties *pCloudProp =
 513                                                     (SCCoapCloudServerConfProperties*) (*userdata);
 514                     pCloudProp->uid[0] = '\0';
 515
 516                     OICStrcpy(pCloudProp->uid, MAXLEN_STRING, uid);
 517                     OICStrcpy(g_SCProperties.uid, MAXLEN_STRING, uid);
 518                     OICFree(uid);
 519
 520                     OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %s",
 521                             SC_RSRVD_ES_VENDOR_UID, pCloudProp->uid);
 522                 }
 523             }
 524
 525             //SC_RSRVD_ES_VENDOR_REFRESH_TOKEN
 526             char *refreshToken = NULL;
 527             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_REFRESH_TOKEN, &refreshToken))
 528             {
 529                 if(*userdata == NULL)
 530                 {
 531                     *userdata = (void*)OICMalloc(sizeof(SCCoapCloudServerConfProperties));
 532                     if( *userdata == NULL )
 533                     {
 534                         OIC_LOG(ERROR, SC_ENROLLEE_TAG, "OICMalloc for SCCoapCloudServerConfProperties is failed");
 535                         return ;
 536                     }
 537                     memset(*userdata, 0, sizeof(SCCoapCloudServerConfProperties));
 538                 }
 539
 540                 if (*userdata != NULL)
 541                 {
 542                     SCCoapCloudServerConfProperties *pCloudProp =
 543                                                     (SCCoapCloudServerConfProperties*) (*userdata);
 544                     pCloudProp->refreshToken[0] = '\0';
 545
 546                     OICStrcpy(pCloudProp->refreshToken, MAXLEN_STRING, refreshToken);
 547                     OICStrcpy(g_SCProperties.refreshToken, MAXLEN_STRING, refreshToken);
 548                     OICFree(refreshToken);
 549
 550                     OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %s",
 551                             SC_RSRVD_ES_VENDOR_REFRESH_TOKEN, pCloudProp->refreshToken);
 552                 }
 553             }
 554
 555             ReadTnCdata(payload,userdata);
 556         }
 557     }
 558
 559     OIC_LOG(INFO, SC_ENROLLEE_TAG, "ReadUserdataCb OUT");
 560 }
 561
 562 void WriteUserdataCb(OCRepPayload* payload, char* resourceType)
 563 {
 564     OIC_LOG(INFO, SC_ENROLLEE_TAG, "WriteUserdataCb IN");
 565
 566     if(payload != NULL)
 567     {
 568         if (strstr(resourceType, OC_RSRVD_ES_RES_TYPE_EASYSETUP))
 569         {
 570             OCRepPayloadSetPropInt(payload, SC_RSRVD_ES_VENDOR_NETCONNECTION_STATE, (int) g_SCProperties.netConnectionState);
 571         }
 572
 573         if (strstr(resourceType, OC_RSRVD_ES_RES_TYPE_WIFICONF))
 574         {
 575            OCRepPayload **repPayload = OICCalloc(g_SCProperties.numCandidateAP, sizeof(OCRepPayload *));
 576
 577            for (size_t i = 0; i < (size_t)g_SCProperties.numCandidateAP; i++)
 578            {
 579                repPayload[i] = OCRepPayloadCreate();
 580                if (!repPayload[i])
 581                {
 582                    OCRepPayloadDestroy(payload);
 583                    for (size_t k = 0; k < i; k++)
 584                    {
 585                        OCRepPayloadDestroy(repPayload[k]);
 586                    }
 587                    OCRepPayloadDestroy(*repPayload);
 588                    break;
 589                }
 590                OCRepPayloadSetPropString(repPayload[i], SC_RSRVD_ES_VENDOR_SSID, g_SCProperties.candidateAPInfo[i].ssid);
 591                OCRepPayloadSetPropString(repPayload[i], SC_RSRVD_ES_VENDOR_PASSPHRASE, g_SCProperties.candidateAPInfo[i].passphrase);
 592                OCRepPayloadSetPropString(repPayload[i], SC_RSRVD_ES_VENDOR_BSSID, g_SCProperties.candidateAPInfo[i].bssid);
 593                OCRepPayloadSetPropInt(repPayload[i], SC_RSRVD_ES_VENDOR_CANDIDATE_CHANNEL, g_SCProperties.candidateAPInfo[i].channel);
 594             }
 595             size_t dimensions[MAX_REP_ARRAY_DEPTH] = {g_SCProperties.numCandidateAP, 0, 0};
 596             OCRepPayloadSetPropObjectArray(payload,SC_RSRVD_ES_VENDOR_CANDIDATEAPS, (const struct OCRepPayload **)repPayload, dimensions);
 597         }
 598         if(strstr(resourceType, OC_RSRVD_ES_RES_TYPE_DEVCONF))
 599         {
 600 #ifndef __TIZENRT__
 601             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_DEVICE_TYPE, g_SCProperties.deviceType);
 602             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_DEVICE_SUBTYPE, g_SCProperties.deviceSubType);
 603             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_REGISTER_SET_DEV, g_SCProperties.regSetDev);
 604             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_REGISTER_MOBILE_DEV, g_SCProperties.regMobileDev);
 605             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_NETWORK_PROV_INFO, g_SCProperties.nwProvInfo);
 606             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_SSO_LIST, g_SCProperties.ssoList);
 607             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_PNP_PIN, g_SCProperties.pnpPin);
 608             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_MODEL_NUMBER, g_SCProperties.modelNumber);
 609             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_COUNTRY, g_SCProperties.country);
 610             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_LANGUAGE, g_SCProperties.language);
 611             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_GPSLOCATION, g_SCProperties.gpsLocation);
 612             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_UTC_DATE_TIME, g_SCProperties.utcDateTime);
 613             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_REGIONAL_DATE_TIME, g_SCProperties.regionalDateTime);
 614             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_ES_PROTOCOL_VERSION, g_SCProperties.esProtocolVersion);
 615 #else
 616             if(g_SCProperties.deviceType != NULL)
 617             {
 618                 OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_DEVICE_TYPE, g_SCProperties.deviceType);
 619             }
 620             if(g_SCProperties.deviceSubType != NULL)
 621             {
 622                 OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_DEVICE_SUBTYPE, g_SCProperties.deviceSubType);
 623             }
 624             if(g_SCProperties.regSetDev != NULL)
 625             {
 626                 OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_REGISTER_SET_DEV, g_SCProperties.regSetDev);
 627             }
 628             if(g_SCProperties.regMobileDev != NULL)
 629             {
 630                 OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_REGISTER_MOBILE_DEV, g_SCProperties.regMobileDev);
 631             }
 632             if(g_SCProperties.nwProvInfo!= NULL)
 633             {
 634                 OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_NETWORK_PROV_INFO, g_SCProperties.nwProvInfo);
 635             }
 636             if(g_SCProperties.ssoList!= NULL)
 637             {
 638                 OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_SSO_LIST, g_SCProperties.ssoList);
 639             }
 640             if(g_SCProperties.pnpPin != NULL)
 641             {
 642                OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_PNP_PIN, g_SCProperties.pnpPin);
 643             }
 644             if(g_SCProperties.modelNumber != NULL)
 645             {
 646                OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_MODEL_NUMBER, g_SCProperties.modelNumber);
 647             }
 648             if(g_SCProperties.country != NULL)
 649             {
 650                OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_COUNTRY, g_SCProperties.country);
 651             }
 652             if(g_SCProperties.language != NULL)
 653             {
 654                OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_LANGUAGE, g_SCProperties.language);
 655             }
 656             if(g_SCProperties.gpsLocation != NULL)
 657             {
 658                OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_GPSLOCATION, g_SCProperties.gpsLocation);
 659             }
 660             if(g_SCProperties.esProtocolVersion != NULL)
 661             {
 662                 OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_ES_PROTOCOL_VERSION, g_SCProperties.esProtocolVersion);
 663             }
 664 #endif
 665         }
 666     }
 667
 668     WriteTnCdata(payload, resourceType);
 669     WriteWifiData(payload, resourceType);
 670
 671     OIC_LOG(INFO, SC_ENROLLEE_TAG, "WriteUserdataCb OUT");
 672 }