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 ESResult SetSSOList(const char *ssoList)
 242 {
 243     if(ssoList != NULL)
 244     {
 245         OICStrcpy(g_SCProperties.ssoList, sizeof(g_SCProperties.ssoList), ssoList);
 246         return ES_OK;
 247     }
 248     return ES_ERROR;
 249 }
 250
 251 void ReadUserdataCb(OCRepPayload* payload, char* resourceType, void** userdata)
 252 {
 253     OIC_LOG(INFO, SC_ENROLLEE_TAG, "ReadUserdataCb IN");
 254
 255     if(payload != NULL)
 256     {
 257         if(strstr(resourceType, OC_RSRVD_ES_RES_TYPE_WIFICONF))
 258         {
 259             int64_t channel = -1;
 260             char *bssid = NULL;
 261             bool isHidden = false;
 262             if (OCRepPayloadGetPropInt(payload, SC_RSRVD_ES_VENDOR_DISCOVERY_CHANNEL, &channel))
 263             {
 264                 if(*userdata == NULL)
 265                 {
 266                     *userdata = (void*)OICMalloc(sizeof(SCWiFiConfProperties));
 267                     if( *userdata == NULL )
 268                     {
 269                         OIC_LOG(ERROR, SC_ENROLLEE_TAG, "OICMalloc for SCWiFiConfProperties is failed");
 270                         return ;
 271                     }
 272                     memset(*userdata, 0, sizeof(SCWiFiConfProperties));
 273                 }
 274                 OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : [%" PRId64 "]",
 275                                                             SC_RSRVD_ES_VENDOR_DISCOVERY_CHANNEL, channel);
 276                 ((SCWiFiConfProperties*)(*userdata))->discoveryChannel = (int) channel;
 277                 g_SCProperties.discoveryChannel = channel;
 278             }
 279             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_BSSID, &bssid))
 280             {
 281                 if(*userdata == NULL)
 282                 {
 283                     *userdata = (void*) OICMalloc(sizeof(SCWiFiConfProperties));
 284                     if( *userdata == NULL )
 285                     {
 286                         OIC_LOG(ERROR, SC_ENROLLEE_TAG, "OICMalloc for SCWiFiConfProperties is failed");
 287                         return ;
 288                     }
 289                     memset(*userdata, 0, sizeof(SCWiFiConfProperties));
 290                 }
 291                 if (*userdata != NULL)
 292                 {
 293                     OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %s",
 294                             SC_RSRVD_ES_VENDOR_BSSID, bssid);
 295                     SCWiFiConfProperties* pWifiConfProp = (SCWiFiConfProperties*)(*userdata);
 296                     OICStrcpy(pWifiConfProp->bssid, sizeof(pWifiConfProp->bssid), bssid);
 297                     OICStrcpy(g_SCProperties.bssid, sizeof(g_SCProperties.bssid), bssid);
 298                     OICFree(bssid);
 299                 }
 300             }
 301
 302             OCRepPayload **repPayload = NULL;
 303             size_t dimensions[MAX_REP_ARRAY_DEPTH];
 304             if(OCRepPayloadGetPropObjectArray(payload, SC_RSRVD_ES_VENDOR_CANDIDATEAPS, &repPayload, dimensions))
 305             {
 306                 if(*userdata == NULL)
 307                 {
 308                     *userdata = (void*) OICMalloc(sizeof(SCWiFiConfProperties));
 309                     if( *userdata == NULL )
 310                     {
 311                         OIC_LOG(ERROR, SC_ENROLLEE_TAG, "OICMalloc for SCWiFiConfProperties is failed");
 312                         return ;
 313                     }
 314                     memset(*userdata, 0, sizeof(SCWiFiConfProperties));
 315                 }
 316                 //size_t dim = calcDimTotal(dimensions);
 317                 SCWiFiConfProperties* pWifiConfProp = (SCWiFiConfProperties*)(*userdata);
 318                 for (size_t i = 0; i < dimensions[0]; i++)
 319                 {
 320                    int64_t cd_channel = -1;
 321                    char *cd_bssid = NULL;
 322                    char *ssid = NULL;
 323                    char *pwd = NULL;
 324                    if (OCRepPayloadGetPropString(repPayload[i], SC_RSRVD_ES_VENDOR_SSID, &ssid))
 325                    {
 326                        OICStrcpy(pWifiConfProp->candidateAPInfo[i].ssid, sizeof(pWifiConfProp->candidateAPInfo[i].ssid), ssid);
 327                        OICStrcpy(g_SCProperties.candidateAPInfo[i].ssid, sizeof(g_SCProperties.candidateAPInfo[i].ssid), ssid);
 328                        OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %s",
 329                             SC_RSRVD_ES_VENDOR_SSID, ssid);
 330                        OICFree(ssid);
 331                    }
 332                    if (OCRepPayloadGetPropString(repPayload[i], SC_RSRVD_ES_VENDOR_PASSPHRASE, &pwd))
 333                    {
 334                        OICStrcpy(pWifiConfProp->candidateAPInfo[i].passphrase, sizeof(pWifiConfProp->candidateAPInfo[i].passphrase), pwd);
 335                        OICStrcpy(g_SCProperties.candidateAPInfo[i].passphrase, sizeof(g_SCProperties.candidateAPInfo[i].passphrase), pwd);
 336                                               OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %s",
 337                             SC_RSRVD_ES_VENDOR_PASSPHRASE, ssid);
 338                        OICFree(pwd);
 339                    }
 340                    if (OCRepPayloadGetPropInt(repPayload[i], SC_RSRVD_ES_VENDOR_CANDIDATE_CHANNEL, &cd_channel))
 341                    {
 342                        pWifiConfProp->candidateAPInfo[i].channel = (int) cd_channel;
 343                        g_SCProperties.candidateAPInfo[i].channel = cd_channel;
 344                                               OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %d",
 345                             SC_RSRVD_ES_VENDOR_CANDIDATE_CHANNEL, (int) cd_channel);
 346                    }
 347                    if (OCRepPayloadGetPropString(repPayload[i], SC_RSRVD_ES_VENDOR_BSSID, &cd_bssid))
 348                    {
 349                        OICStrcpy(pWifiConfProp->candidateAPInfo[i].bssid, sizeof(pWifiConfProp->candidateAPInfo[i].bssid), cd_bssid);
 350                        OICStrcpy(g_SCProperties.candidateAPInfo[i].bssid, sizeof(g_SCProperties.candidateAPInfo[i].bssid), cd_bssid);
 351                                               OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %s",
 352                             SC_RSRVD_ES_VENDOR_BSSID, cd_bssid);
 353                        OICFree(bssid);
 354                    }
 355                 }
 356                 pWifiConfProp->numCandidateAP = (int)dimensions[0];
 357                 g_SCProperties.numCandidateAP = (int)dimensions[0];
 358             }
 359
 360             if (OCRepPayloadGetPropBool(payload, SC_RSRVD_ES_VENDOR_HIDDEN, &isHidden))
 361             {
 362                 if(*userdata == NULL)
 363                 {
 364                     *userdata = (void*)OICMalloc(sizeof(SCWiFiConfProperties));
 365                     if( *userdata == NULL )
 366                     {
 367                         OIC_LOG(ERROR, SC_ENROLLEE_TAG, "OICMalloc for SCWiFiConfProperties is failed");
 368                         return ;
 369                     }
 370                     memset(*userdata, 0, sizeof(SCWiFiConfProperties));
 371                 }
 372                 OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %d",
 373                                                             SC_RSRVD_ES_VENDOR_HIDDEN, isHidden);
 374                 ((SCWiFiConfProperties*)(*userdata))->isHidden = isHidden;
 375                 g_SCProperties.isHidden = isHidden;
 376             }
 377         }
 378         else if(strstr(resourceType, OC_RSRVD_ES_RES_TYPE_DEVCONF))
 379         {
 380             if(*userdata == NULL)
 381             {
 382                 *userdata = (void*)OICMalloc(sizeof(SCDevConfProperties));
 383                 if( *userdata == NULL )
 384                 {
 385                     OIC_LOG(ERROR, SC_ENROLLEE_TAG, "OICMalloc for SCDevConfProperties is failed");
 386                     return ;
 387                 }
 388                 memset(*userdata, 0, sizeof(SCDevConfProperties));
 389             }
 390
 391             SCDevConfProperties *pDevConfProp = (SCDevConfProperties*)(*userdata);
 392
 393             char**locationList = NULL;
 394             size_t dimensions[MAX_REP_ARRAY_DEPTH] = {0};
 395             if(OCRepPayloadGetStringArray(payload, SC_RSRVD_ES_VENDOR_LOCATION, &locationList, dimensions))
 396             {
 397                 for(size_t idx = 0; idx < dimensions[0]; idx++)
 398                 {
 399                     OICStrcpy(pDevConfProp->location[idx], strlen(locationList[idx])+1, locationList[idx]);
 400                     OICStrcpy(g_SCProperties.location[idx], strlen(locationList[idx])+1, locationList[idx]);
 401
 402                     OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %s",
 403                                         SC_RSRVD_ES_VENDOR_LOCATION, pDevConfProp->location[idx]);
 404                 }
 405
 406                 ((SCDevConfProperties*)(*userdata))->numLocation = (int)dimensions[0];
 407                 g_SCProperties.numLocation = (int)dimensions[0];
 408             }
 409
 410             ReadAccountData(payload,userdata);
 411
 412             char *regMobileDev = NULL;
 413             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_REGISTER_MOBILE_DEV, &regMobileDev))
 414             {
 415                 OICStrcpy(pDevConfProp->regMobileDev, strlen(regMobileDev)+1, regMobileDev);
 416                 OICStrcpy(g_SCProperties.regMobileDev, strlen(regMobileDev)+1, regMobileDev);
 417                 OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "pDevConfProp.regMobileDev %s", g_SCProperties.regMobileDev);
 418             }
 419
 420             char *country = NULL;
 421             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_COUNTRY, &country))
 422             {
 423                 OICStrcpy(pDevConfProp->country, strlen(country)+1, country);
 424                 OICStrcpy(g_SCProperties.country, strlen(country)+1, country);
 425                 OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "pDevConfProp.country %s", g_SCProperties.country);
 426             }
 427
 428             char *language = NULL;
 429             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_LANGUAGE, &language))
 430             {
 431                 OICStrcpy(pDevConfProp->language, strlen(language)+1, language);
 432                 OICStrcpy(g_SCProperties.language, strlen(language)+1, language);
 433                 OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "pDevConfProp.language %s", g_SCProperties.language);
 434             }
 435
 436             char *gpsLocation = NULL;
 437             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_GPSLOCATION, &gpsLocation))
 438             {
 439                 OICStrcpy(pDevConfProp->gpsLocation, strlen(gpsLocation)+1, gpsLocation);
 440                 OICStrcpy(g_SCProperties.gpsLocation, strlen(gpsLocation)+1, gpsLocation);
 441                 OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "pDevConfProp.gpsLocation %s", g_SCProperties.gpsLocation);
 442             }
 443
 444             char *utcDateTime = NULL;
 445             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_UTC_DATE_TIME, &utcDateTime))
 446             {
 447                 OICStrcpy(pDevConfProp->utcDateTime, strlen(utcDateTime)+1, utcDateTime);
 448                 OICStrcpy(g_SCProperties.utcDateTime, strlen(utcDateTime)+1, utcDateTime);
 449                 OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "pDevConfProp.utcDateTime %s", g_SCProperties.utcDateTime);
 450             }
 451
 452             char *regionalDateTime = NULL;
 453             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_REGIONAL_DATE_TIME, &regionalDateTime))
 454             {
 455                 OICStrcpy(pDevConfProp->regionalDateTime, strlen(regionalDateTime)+1, regionalDateTime);
 456                 OICStrcpy(g_SCProperties.regionalDateTime, strlen(regionalDateTime)+1, regionalDateTime);
 457                 OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "pDevConfProp.regionalDateTime %s", g_SCProperties.regionalDateTime);
 458             }
 459
 460             char *timeZoneId = NULL;
 461             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_TIMEZONE_ID, &timeZoneId))
 462             {
 463                 OICStrcpy(pDevConfProp->timeZoneId, strlen(timeZoneId)+1, timeZoneId);
 464                 OICStrcpy(g_SCProperties.timeZoneId, strlen(timeZoneId)+1, timeZoneId);
 465                 OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "pDevConfProp.timeZoneId %s", g_SCProperties.timeZoneId);
 466             }
 467
 468             char *ssoList = NULL;
 469             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_SSO_LIST, &ssoList))
 470             {
 471                 OICStrcpy(pDevConfProp->ssoList, strlen(ssoList)+1, ssoList);
 472                 OICStrcpy(g_SCProperties.ssoList, strlen(ssoList)+1, ssoList);
 473                 OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "pDevConfProp.ssoList %s", g_SCProperties.ssoList);
 474             }
 475         }
 476         else if(strstr(resourceType, OC_RSRVD_ES_RES_TYPE_COAPCLOUDCONF))
 477         {
 478             char* clientID = NULL;
 479             if(OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_CLIENTID, &clientID))
 480             {
 481                 if(*userdata == NULL)
 482                 {
 483                     *userdata = (void*)OICMalloc(sizeof(SCCoapCloudServerConfProperties));
 484                     if( *userdata == NULL )
 485                     {
 486                         OIC_LOG(ERROR, SC_ENROLLEE_TAG, "OICMalloc for SCCoapCloudServerConfProperties is failed");
 487                         return ;
 488                     }
 489                     memset(*userdata, 0, sizeof(SCCoapCloudServerConfProperties));
 490                 }
 491
 492                 SCCoapCloudServerConfProperties *pCloudProp =
 493                                                     (SCCoapCloudServerConfProperties*)(*userdata);
 494
 495                 OICStrcpy(pCloudProp->clientID, strlen(clientID)+1, clientID);
 496                 OICStrcpy(g_SCProperties.clientID, strlen(clientID)+1, clientID);
 497
 498                 OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %s",
 499                                         SC_RSRVD_ES_VENDOR_CLIENTID, pCloudProp->clientID);
 500             }
 501
 502             //SC_RSRVD_ES_VENDOR_AAC
 503             char *aac = NULL;
 504             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_AAC, &aac))
 505             {
 506                 if(*userdata == NULL)
 507                 {
 508                     *userdata = (void*)OICMalloc(sizeof(SCCoapCloudServerConfProperties));
 509                     if( *userdata == NULL )
 510                     {
 511                         OIC_LOG(ERROR, SC_ENROLLEE_TAG, "OICMalloc for SCCoapCloudServerConfProperties is failed");
 512                         return ;
 513                     }
 514                     memset(*userdata, 0, sizeof(SCCoapCloudServerConfProperties));
 515                 }
 516
 517                 if (*userdata != NULL)
 518                 {
 519                     SCCoapCloudServerConfProperties *pCloudProp =
 520                                                     (SCCoapCloudServerConfProperties*) (*userdata);
 521                     pCloudProp->aac[0] = '\0';
 522
 523                     OICStrcpy(pCloudProp->aac, MAXLEN_STRING, aac);
 524                     OICStrcpy(g_SCProperties.aac, MAXLEN_STRING, aac);
 525                     OICFree(aac);
 526
 527                     OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %s",
 528                             SC_RSRVD_ES_VENDOR_AAC, pCloudProp->aac);
 529                 }
 530             }
 531
 532             //SC_RSRVD_ES_VENDOR_UID
 533             char *uid = NULL;
 534             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_UID, &uid))
 535             {
 536                 if(*userdata == NULL)
 537                 {
 538                     *userdata = (void*)OICMalloc(sizeof(SCCoapCloudServerConfProperties));
 539                     if( *userdata == NULL )
 540                     {
 541                         OIC_LOG(ERROR, SC_ENROLLEE_TAG, "OICMalloc for SCCoapCloudServerConfProperties is failed");
 542                         return ;
 543                     }
 544                     memset(*userdata, 0, sizeof(SCCoapCloudServerConfProperties));
 545                 }
 546
 547                 if (*userdata != NULL)
 548                 {
 549                     SCCoapCloudServerConfProperties *pCloudProp =
 550                                                     (SCCoapCloudServerConfProperties*) (*userdata);
 551                     pCloudProp->uid[0] = '\0';
 552
 553                     OICStrcpy(pCloudProp->uid, MAXLEN_STRING, uid);
 554                     OICStrcpy(g_SCProperties.uid, MAXLEN_STRING, uid);
 555                     OICFree(uid);
 556
 557                     OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %s",
 558                             SC_RSRVD_ES_VENDOR_UID, pCloudProp->uid);
 559                 }
 560             }
 561
 562             //SC_RSRVD_ES_VENDOR_REFRESH_TOKEN
 563             char *refreshToken = NULL;
 564             if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_REFRESH_TOKEN, &refreshToken))
 565             {
 566                 if(*userdata == NULL)
 567                 {
 568                     *userdata = (void*)OICMalloc(sizeof(SCCoapCloudServerConfProperties));
 569                     if( *userdata == NULL )
 570                     {
 571                         OIC_LOG(ERROR, SC_ENROLLEE_TAG, "OICMalloc for SCCoapCloudServerConfProperties is failed");
 572                         return ;
 573                     }
 574                     memset(*userdata, 0, sizeof(SCCoapCloudServerConfProperties));
 575                 }
 576
 577                 if (*userdata != NULL)
 578                 {
 579                     SCCoapCloudServerConfProperties *pCloudProp =
 580                                                     (SCCoapCloudServerConfProperties*) (*userdata);
 581                     pCloudProp->refreshToken[0] = '\0';
 582
 583                     OICStrcpy(pCloudProp->refreshToken, MAXLEN_STRING, refreshToken);
 584                     OICStrcpy(g_SCProperties.refreshToken, MAXLEN_STRING, refreshToken);
 585                     OICFree(refreshToken);
 586
 587                     OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %s",
 588                             SC_RSRVD_ES_VENDOR_REFRESH_TOKEN, pCloudProp->refreshToken);
 589                 }
 590             }
 591
 592             ReadTnCdata(payload,userdata);
 593         }
 594     }
 595
 596     OIC_LOG(INFO, SC_ENROLLEE_TAG, "ReadUserdataCb OUT");
 597 }
 598
 599 void WriteUserdataCb(OCRepPayload* payload, char* resourceType)
 600 {
 601     OIC_LOG(INFO, SC_ENROLLEE_TAG, "WriteUserdataCb IN");
 602
 603     if(payload != NULL)
 604     {
 605         if (strstr(resourceType, OC_RSRVD_ES_RES_TYPE_EASYSETUP))
 606         {
 607             OCRepPayloadSetPropInt(payload, SC_RSRVD_ES_VENDOR_NETCONNECTION_STATE, (int) g_SCProperties.netConnectionState);
 608         }
 609
 610         if (strstr(resourceType, OC_RSRVD_ES_RES_TYPE_WIFICONF))
 611         {
 612            OCRepPayload **repPayload = OICCalloc(g_SCProperties.numCandidateAP, sizeof(OCRepPayload *));
 613
 614            for (size_t i = 0; i < (size_t)g_SCProperties.numCandidateAP; i++)
 615            {
 616                repPayload[i] = OCRepPayloadCreate();
 617                if (!repPayload[i])
 618                {
 619                    OCRepPayloadDestroy(payload);
 620                    for (size_t k = 0; k < i; k++)
 621                    {
 622                        OCRepPayloadDestroy(repPayload[k]);
 623                    }
 624                    OCRepPayloadDestroy(*repPayload);
 625                    break;
 626                }
 627                OCRepPayloadSetPropString(repPayload[i], SC_RSRVD_ES_VENDOR_SSID, g_SCProperties.candidateAPInfo[i].ssid);
 628                OCRepPayloadSetPropString(repPayload[i], SC_RSRVD_ES_VENDOR_PASSPHRASE, g_SCProperties.candidateAPInfo[i].passphrase);
 629                OCRepPayloadSetPropString(repPayload[i], SC_RSRVD_ES_VENDOR_BSSID, g_SCProperties.candidateAPInfo[i].bssid);
 630                OCRepPayloadSetPropInt(repPayload[i], SC_RSRVD_ES_VENDOR_CANDIDATE_CHANNEL, g_SCProperties.candidateAPInfo[i].channel);
 631             }
 632             size_t dimensions[MAX_REP_ARRAY_DEPTH] = {g_SCProperties.numCandidateAP, 0, 0};
 633             OCRepPayloadSetPropObjectArray(payload,SC_RSRVD_ES_VENDOR_CANDIDATEAPS, (const struct OCRepPayload **)repPayload, dimensions);
 634         }
 635         if(strstr(resourceType, OC_RSRVD_ES_RES_TYPE_DEVCONF))
 636         {
 637 #ifndef __TIZENRT__
 638             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_DEVICE_TYPE, g_SCProperties.deviceType);
 639             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_DEVICE_SUBTYPE, g_SCProperties.deviceSubType);
 640             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_REGISTER_SET_DEV, g_SCProperties.regSetDev);
 641             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_REGISTER_MOBILE_DEV, g_SCProperties.regMobileDev);
 642             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_NETWORK_PROV_INFO, g_SCProperties.nwProvInfo);
 643             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_SSO_LIST, g_SCProperties.ssoList);
 644             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_PNP_PIN, g_SCProperties.pnpPin);
 645             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_MODEL_NUMBER, g_SCProperties.modelNumber);
 646             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_COUNTRY, g_SCProperties.country);
 647             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_LANGUAGE, g_SCProperties.language);
 648             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_GPSLOCATION, g_SCProperties.gpsLocation);
 649             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_UTC_DATE_TIME, g_SCProperties.utcDateTime);
 650             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_REGIONAL_DATE_TIME, g_SCProperties.regionalDateTime);
 651             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_ES_PROTOCOL_VERSION, g_SCProperties.esProtocolVersion);
 652             OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_HUB_ID, g_SCProperties.hubId);
 653 #else
 654             if(g_SCProperties.deviceType != NULL)
 655             {
 656                 OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_DEVICE_TYPE, g_SCProperties.deviceType);
 657             }
 658             if(g_SCProperties.deviceSubType != NULL)
 659             {
 660                 OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_DEVICE_SUBTYPE, g_SCProperties.deviceSubType);
 661             }
 662             if(g_SCProperties.regSetDev != NULL)
 663             {
 664                 OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_REGISTER_SET_DEV, g_SCProperties.regSetDev);
 665             }
 666             if(g_SCProperties.regMobileDev != NULL)
 667             {
 668                 OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_REGISTER_MOBILE_DEV, g_SCProperties.regMobileDev);
 669             }
 670             if(g_SCProperties.nwProvInfo!= NULL)
 671             {
 672                 OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_NETWORK_PROV_INFO, g_SCProperties.nwProvInfo);
 673             }
 674             if(g_SCProperties.ssoList!= NULL)
 675             {
 676                 OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_SSO_LIST, g_SCProperties.ssoList);
 677             }
 678             if(g_SCProperties.pnpPin != NULL)
 679             {
 680                OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_PNP_PIN, g_SCProperties.pnpPin);
 681             }
 682             if(g_SCProperties.modelNumber != NULL)
 683             {
 684                OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_MODEL_NUMBER, g_SCProperties.modelNumber);
 685             }
 686             if(g_SCProperties.country != NULL)
 687             {
 688                OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_COUNTRY, g_SCProperties.country);
 689             }
 690             if(g_SCProperties.language != NULL)
 691             {
 692                OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_LANGUAGE, g_SCProperties.language);
 693             }
 694             if(g_SCProperties.gpsLocation != NULL)
 695             {
 696                OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_GPSLOCATION, g_SCProperties.gpsLocation);
 697             }
 698             if(g_SCProperties.esProtocolVersion != NULL)
 699             {
 700                 OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_ES_PROTOCOL_VERSION, g_SCProperties.esProtocolVersion);
 701             }
 702             if (g_SCProperties.hubId != NULL)
 703             {
 704                 OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_HUB_ID, g_SCProperties.hubId);
 705             }
 706 #endif
 707         }
 708     }
 709
 710     WriteTnCdata(payload, resourceType);
 711     WriteWifiData(payload, resourceType);
 712
 713     OIC_LOG(INFO, SC_ENROLLEE_TAG, "WriteUserdataCb OUT");
 714 }