server/Source/interface_srpcserver.c

   1 /**************************************************************************************************
   2  * Filename:       interface_srpcserver.c
   3  * Description:    Socket Remote Procedure Call Interface - sample device application.
   4  *
   5  *
   6  * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com/
   7  *
   8  *
   9  *  Redistribution and use in source and binary forms, with or without
  10  *  modification, are permitted provided that the following conditions
  11  *  are met:
  12  *
  13  *    Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  *
  16  *    Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the
  19  *    distribution.
  20  *
  21  *    Neither the name of Texas Instruments Incorporated nor the names of
  22  *    its contributors may be used to endorse or promote products derived
  23  *    from this software without specific prior written permission.
  24  *
  25  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  26  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  27  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  28  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  29  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  30  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  31  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  32  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  33  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  34  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  35  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  *
  37  */
  38
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <unistd.h>
  43 #include <sys/types.h>
  44 #include <sys/socket.h>
  45 #include <netinet/in.h>
  46 #include <fcntl.h>
  47 #include <sys/signal.h>
  48 #include <sys/ioctl.h>
  49 #include <poll.h>
  50
  51 #include "interface_srpcserver.h"
  52 #include "socket_server.h"
  53 #include "interface_devicelist.h"
  54 #include "interface_grouplist.h"
  55 #include "interface_scenelist.h"
  56
  57 #include "hal_defs.h"
  58
  59 #include "zbSocCmd.h"
  60
  61 void SRPC_RxCB(int clientFd);
  62 void SRPC_ConnectCB(int status);
  63
  64 static uint8_t SRPC_setDeviceState(uint8_t *pBuf, uint32_t clientFd);
  65 static uint8_t SRPC_setDeviceLevel(uint8_t *pBuf, uint32_t clientFd);
  66 static uint8_t SRPC_setDeviceColor(uint8_t *pBuf, uint32_t clientFd);
  67 static uint8_t SRPC_getDeviceState(uint8_t *pBuf, uint32_t clientFd);
  68 static uint8_t SRPC_getDeviceLevel(uint8_t *pBuf, uint32_t clientFd);
  69 static uint8_t SRPC_getDeviceHue(uint8_t *pBuf, uint32_t clientFd);
  70 static uint8_t SRPC_getDeviceSat(uint8_t *pBuf, uint32_t clientFd);
  71 static uint8_t SRPC_bindDevices(uint8_t *pBuf, uint32_t clientFd);
  72 static uint8_t SRPC_getGroups(uint8_t *pBuf, uint32_t clientFd);
  73 static uint8_t SRPC_addGroup(uint8_t *pBuf, uint32_t clientFd);
  74 static uint8_t SRPC_getScenes(uint8_t *pBuf, uint32_t clientFd);
  75 static uint8_t SRPC_storeScene(uint8_t *pBuf, uint32_t clientFd);
  76 static uint8_t SRPC_recallScene(uint8_t *pBuf, uint32_t clientFd);
  77 static uint8_t SRPC_identifyDevice(uint8_t *pBuf, uint32_t clientFd);
  78 static uint8_t SRPC_close(uint8_t *pBuf, uint32_t clientFd);
  79 static uint8_t SRPC_getDevices(uint8_t *pBuf, uint32_t clientFd);
  80 static uint8_t SRPC_permitJoin(uint8_t *pBuf, uint32_t clientFd);
  81 static uint8_t SRPC_changeDeviceName(uint8_t *pBuf, uint32_t clientFd);
  82 static uint8_t SRPC_notSupported(uint8_t *pBuf, uint32_t clientFd);
  83
  84 //RPSC ZLL Interface call back functions
  85 static void SRPC_CallBack_addGroupRsp(uint16_t groupId, char *nameStr,
  86                 uint32_t clientFd);
  87 static void SRPC_CallBack_addSceneRsp(uint16_t groupId, uint8_t sceneId,
  88                 char *nameStr, uint32_t clientFd);
  89
  90 static uint8_t* srpcParseEpInfo(epInfoExtended_t* epInfoEx);
  91
  92 typedef uint8_t (*srpcProcessMsg_t)(uint8_t *pBuf, uint32_t clientFd);
  93
  94 srpcProcessMsg_t rpcsProcessIncoming[] =
  95 { SRPC_close, //SRPC_CLOSE
  96                 SRPC_getDevices, //SRPC_GET_DEVICES
  97                 SRPC_setDeviceState, //SRPC_SET_DEV_STATE
  98                 SRPC_setDeviceLevel, //SRPC_SET_DEV_LEVEL
  99                 SRPC_setDeviceColor, //SRPC_SET_DEV_COLOR
 100                 SRPC_getDeviceState, //SRPC_GET_DEV_STATE
 101                 SRPC_getDeviceLevel, //SRPC_GET_DEV_LEVEL
 102                 SRPC_getDeviceHue, //SRPC_GET_DEV_HUE
 103                 SRPC_getDeviceSat, //SRPC_GET_DEV_HUE
 104                 SRPC_bindDevices, //SRPC_BIND_DEVICES
 105                 SRPC_notSupported, //reserved
 106                 SRPC_notSupported, //reserved
 107                 SRPC_notSupported, //reserved
 108                 SRPC_notSupported, //reserved
 109                 SRPC_getGroups, //SRPC_GET_GROUPS
 110                 SRPC_addGroup, //SRPC_ADD_GROUP
 111                 SRPC_getScenes, //SRPC_GET_SCENES
 112                 SRPC_storeScene, //SRPC_STORE_SCENE
 113                 SRPC_recallScene, //SRPC_RECALL_SCENE
 114                 SRPC_identifyDevice, //SRPC_IDENTIFY_DEVICE
 115                 SRPC_changeDeviceName, //SRPC_CHANGE_DEVICE_NAME
 116                 SRPC_notSupported, //SRPC_REMOVE_DEVICE
 117                 SRPC_notSupported, //SRPC_RESERVED_10
 118                 SRPC_notSupported, //SRPC_RESERVED_11
 119                 SRPC_notSupported, //SRPC_RESERVED_12
 120                 SRPC_notSupported, //SRPC_RESERVED_13
 121                 SRPC_notSupported, //SRPC_RESERVED_14
 122                 SRPC_notSupported, //SRPC_RESERVED_15
 123                 SRPC_permitJoin, //SRPC_PERMIT_JOIN
 124                 };
 125
 126 static void srpcSend(uint8_t* srpcMsg, int fdClient);
 127 static void srpcSendAll(uint8_t* srpcMsg);
 128
 129 /***************************************************************************************************
 130  * @fn      srpcParseEpInfp - Parse epInfo and prepare the SRPC message.
 131  *
 132  * @brief   Parse epInfo and prepare the SRPC message.
 133  * @param   epInfo_t* epInfo
 134  *
 135  * @return  pSrpcMessage
 136  ***************************************************************************************************/
 137 static uint8_t* srpcParseEpInfo(epInfoExtended_t* epInfoEx)
 138 {
 139         uint8_t i;
 140         uint8_t *pSrpcMessage, *pTmp, devNameLen = 0, pSrpcMessageLen;
 141
 142         //printf("srpcParseEpInfo++\n");
 143
 144         //RpcMessage contains function ID param Data Len and param data
 145         if (epInfoEx->epInfo->deviceName)
 146         {
 147                 devNameLen = strlen(epInfoEx->epInfo->deviceName);
 148         }
 149
 150         //sizre of EP infor - the name char* + num bytes of device name
 151         //pSrpcMessageLen = sizeof(epInfo_t) - sizeof(char*) + devNameLen;
 152         pSrpcMessageLen = 2 /* network address */
 153         + 1 /* endpoint */
 154         + 2 /* profile ID */
 155         + 2 /* device ID */
 156         + 1 /* version */
 157         + 1 /* device name length */
 158         + devNameLen /* device name */
 159         + 1 /* status */
 160         + 8 /* IEEE address */
 161         + 1 /* type */
 162         + 2 /* previous network address */
 163         + 1; /* flags */
 164         pSrpcMessage = malloc(pSrpcMessageLen + 2);
 165
 166         pTmp = pSrpcMessage;
 167
 168         if (pSrpcMessage)
 169         {
 170                 //Set func ID in SRPC buffer
 171                 *pTmp++ = SRPC_NEW_DEVICE;
 172                 //param size
 173                 *pTmp++ = pSrpcMessageLen;
 174
 175                 *pTmp++ = LO_UINT16(epInfoEx->epInfo->nwkAddr);
 176                 *pTmp++ = HI_UINT16(epInfoEx->epInfo->nwkAddr);
 177                 *pTmp++ = epInfoEx->epInfo->endpoint;
 178                 *pTmp++ = LO_UINT16(epInfoEx->epInfo->profileID);
 179                 *pTmp++ = HI_UINT16(epInfoEx->epInfo->profileID);
 180                 *pTmp++ = LO_UINT16(epInfoEx->epInfo->deviceID);
 181                 *pTmp++ = HI_UINT16(epInfoEx->epInfo->deviceID);
 182                 *pTmp++ = epInfoEx->epInfo->version;
 183
 184                 if (devNameLen > 0)
 185                 {
 186                         *pTmp++ = devNameLen;
 187                         for (i = 0; i < devNameLen; i++)
 188                         {
 189                                 *pTmp++ = epInfoEx->epInfo->deviceName[i];
 190                         }
 191                         printf("srpcParseEpInfo: name:%s\n", epInfoEx->epInfo->deviceName);
 192                 }
 193                 else
 194                 {
 195                         *pTmp++ = 0;
 196                 }
 197                 *pTmp++ = epInfoEx->epInfo->status;
 198
 199                 for (i = 0; i < 8; i++)
 200                 {
 201                         //printf("srpcParseEpInfp: IEEEAddr[%d] = %x\n", i, epInfo->IEEEAddr[i]);
 202                         *pTmp++ = epInfoEx->epInfo->IEEEAddr[i];
 203                 }
 204
 205                 *pTmp++ = epInfoEx->type;
 206                 *pTmp++ = LO_UINT16(epInfoEx->prevNwkAddr);
 207                 *pTmp++ = HI_UINT16(epInfoEx->prevNwkAddr);
 208                 *pTmp++ = epInfoEx->epInfo->flags; //bit 0 : start, bit 1: end
 209
 210         }
 211         //printf("srpcParseEpInfp--\n");
 212
 213 //  printf("srpcParseEpInfo %0x:%0x\n", epInfo->nwkAddr, epInfo->endpoint);
 214
 215         printf(
 216                         "srpcParseEpInfo: %s device, nwkAddr=0x%04X, endpoint=0x%X, profileID=0x%04X, deviceID=0x%04X, flags=0x%02X",
 217                         epInfoEx->type == EP_INFO_TYPE_EXISTING ? "EXISTING" :
 218                         epInfoEx->type == EP_INFO_TYPE_NEW ? "NEW" : "UPDATED",
 219                         epInfoEx->epInfo->nwkAddr, epInfoEx->epInfo->endpoint,
 220                         epInfoEx->epInfo->profileID, epInfoEx->epInfo->deviceID,
 221                         epInfoEx->epInfo->flags);
 222
 223         if (epInfoEx->type == EP_INFO_TYPE_UPDATED)
 224         {
 225                 printf(", prevNwkAddr=0x%04X\n", epInfoEx->prevNwkAddr);
 226         }
 227
 228         printf("\n");
 229
 230         return pSrpcMessage;
 231 }
 232
 233 /***************************************************************************************************
 234  * @fn      srpcSend
 235  *
 236  * @brief   Send a message over SRPC to a clients.
 237  * @param   uint8_t* srpcMsg - message to be sent
 238  *
 239  * @return  Status
 240  ***************************************************************************************************/
 241 static void srpcSend(uint8_t* srpcMsg, int fdClient)
 242 {
 243         int rtn;
 244
 245         rtn = socketSeverSend(srpcMsg, (srpcMsg[SRPC_MSG_LEN] + 2), fdClient);
 246         if (rtn < 0)
 247         {
 248                 printf("ERROR writing to socket\n");
 249         }
 250
 251         return;
 252 }
 253
 254 /***************************************************************************************************
 255  * @fn      srpcSendAll
 256  *
 257  * @brief   Send a message over SRPC to all clients.
 258  * @param   uint8_t* srpcMsg - message to be sent
 259  *
 260  * @return  Status
 261  ***************************************************************************************************/
 262 static void srpcSendAll(uint8_t* srpcMsg)
 263 {
 264         int rtn;
 265
 266         rtn = socketSeverSendAllclients(srpcMsg, (srpcMsg[SRPC_MSG_LEN] + 2));
 267         if (rtn < 0)
 268         {
 269                 printf("ERROR writing to socket\n");
 270         }
 271
 272         return;
 273 }
 274
 275 /*********************************************************************
 276  * @fn          SRPC_ProcessIncoming
 277  *
 278  * @brief       This function processes incoming messages.
 279  *
 280  * @param       pBuf - incomin messages
 281  *
 282  * @return      afStatus_t
 283  */
 284 void SRPC_ProcessIncoming(uint8_t *pBuf, uint32_t clientFd)
 285 {
 286         srpcProcessMsg_t func;
 287
 288 //  printf("SRPC_ProcessIncoming++[%x]\n", pBuf[SRPC_FUNC_ID]);
 289         /* look up and call processing function */
 290         func = rpcsProcessIncoming[(pBuf[SRPC_FUNC_ID] & ~(0x80))];
 291         if (func)
 292         {
 293                 (*func)(pBuf, clientFd);
 294         }
 295         else
 296         {
 297                 //printf("Error: no processing function for CMD 0x%x\n", pBuf[SRPC_FUNC_ID]);
 298         }
 299
 300         //printf("SRPC_ProcessIncoming--\n");
 301 }
 302
 303 /*********************************************************************
 304  * @fn          SRPC_addGroup
 305  *
 306  * @brief       This function exposes an interface to add a devices to a group.
 307  *
 308  * @param       pBuf - incomin messages
 309  *
 310  * @return      afStatus_t
 311  */
 312 static uint8_t SRPC_addGroup(uint8_t *pBuf, uint32_t clientFd)
 313 {
 314         uint16_t dstAddr;
 315         uint8_t addrMode;
 316         uint8_t endpoint;
 317         char *nameStr;
 318         uint8_t nameLen;
 319         uint16_t groupId;
 320
 321         //printf("SRPC_addGroup++\n");
 322
 323         //increment past SRPC header
 324         pBuf += 2;
 325
 326         addrMode = (afAddrMode_t) *pBuf++;
 327         dstAddr = BUILD_UINT16(pBuf[0], pBuf[1]);
 328         pBuf += Z_EXTADDR_LEN;
 329         endpoint = *pBuf++;
 330         // index past panId
 331         pBuf += 2;
 332
 333         nameLen = *pBuf++;
 334         nameStr = malloc(nameLen + 1);
 335         int i;
 336         for (i = 0; i < nameLen; i++)
 337         {
 338                 nameStr[i] = *pBuf++;
 339         }
 340         nameStr[nameLen] = '\0';
 341
 342         printf("SRPC_addGroup++: %x:%x:%x name[%d] %s \n", dstAddr, addrMode,
 343                         endpoint, nameLen, nameStr);
 344
 345         groupId = groupListAddDeviceToGroup(nameStr, dstAddr, endpoint);
 346         zbSocAddGroup(groupId, dstAddr, endpoint, addrMode);
 347
 348         SRPC_CallBack_addGroupRsp(groupId, nameStr, clientFd);
 349
 350         free(nameStr);
 351
 352         //printf("SRPC_addGroup--\n");
 353
 354         return 0;
 355 }
 356
 357 /*********************************************************************
 358  * @fn          uint8_t SRPC_storeScene(uint8_t *pBuf, uint32_t clientFd)
 359  *
 360  * @brief       This function exposes an interface to store a scene.
 361  *
 362  * @param       pBuf - incomin messages
 363  *
 364  * @return      afStatus_t
 365  */
 366 static uint8_t SRPC_storeScene(uint8_t *pBuf, uint32_t clientFd)
 367 {
 368         uint16_t dstAddr;
 369         uint8_t addrMode;
 370         uint8_t endpoint;
 371         char *nameStr;
 372         uint8_t nameLen;
 373         uint16_t groupId;
 374         uint8_t sceneId;
 375
 376         //printf("SRPC_storeScene++\n");
 377
 378         //increment past SRPC header
 379         pBuf += 2;
 380
 381         addrMode = (afAddrMode_t) *pBuf++;
 382         dstAddr = BUILD_UINT16(pBuf[0], pBuf[1]);
 383         pBuf += Z_EXTADDR_LEN;
 384         endpoint = *pBuf++;
 385         // index past panId
 386         pBuf += 2;
 387
 388         groupId = BUILD_UINT16(pBuf[0], pBuf[1]);
 389         pBuf += 2;
 390
 391         nameLen = *pBuf++;
 392         nameStr = malloc(nameLen + 1);
 393         int i;
 394         for (i = 0; i < nameLen; i++)
 395         {
 396                 nameStr[i] = *pBuf++;
 397         }
 398         nameStr[nameLen] = '\0';
 399
 400         printf("SRPC_storeScene++: name[%d] %s, group %d \n", nameLen, nameStr, groupId);
 401
 402         sceneId = sceneListAddScene(nameStr, groupId);
 403         zbSocStoreScene(groupId, sceneId, dstAddr, endpoint, addrMode);
 404         SRPC_CallBack_addSceneRsp(groupId, sceneId, nameStr, clientFd);
 405
 406         free(nameStr);
 407
 408         //printf("SRPC_storeScene--: id:%x\n", sceneId);
 409
 410         return 0;
 411 }
 412
 413 /*********************************************************************
 414  * @fn          uint8_t SRPC_recallScene(uint8_t *pBuf, uint32_t clientFd)
 415  *
 416  * @brief       This function exposes an interface to recall a scene.
 417  *
 418  * @param       pBuf - incomin messages
 419  *
 420  * @return      afStatus_t
 421  */
 422 static uint8_t SRPC_recallScene(uint8_t *pBuf, uint32_t clientFd)
 423 {
 424         uint16_t dstAddr;
 425         uint8_t addrMode;
 426         uint8_t endpoint;
 427         char *nameStr;
 428         uint8_t nameLen;
 429         uint16_t groupId;
 430         uint8_t sceneId;
 431
 432         //printf("SRPC_recallScene++\n");
 433
 434         //increment past SRPC header
 435         pBuf += 2;
 436
 437         addrMode = (afAddrMode_t) *pBuf++;
 438         dstAddr = BUILD_UINT16(pBuf[0], pBuf[1]);
 439         pBuf += Z_EXTADDR_LEN;
 440         endpoint = *pBuf++;
 441         // index past panId
 442         pBuf += 2;
 443
 444         groupId = BUILD_UINT16(pBuf[0], pBuf[1]);
 445         pBuf += 2;
 446
 447         nameLen = *pBuf++;
 448         nameStr = malloc(nameLen + 1);
 449         int i;
 450         for (i = 0; i < nameLen; i++)
 451         {
 452                 nameStr[i] = *pBuf++;
 453         }
 454         nameStr[nameLen] = '\0';
 455
 456         printf("SRPC_recallScene++: name[%d] %s, group %d \n", nameLen, nameStr, groupId);
 457
 458         sceneId = sceneListGetSceneId(nameStr, groupId);
 459         zbSocRecallScene(groupId, sceneId, dstAddr, endpoint, addrMode);
 460
 461         free(nameStr);
 462
 463         //printf("SRPC_recallScene--: id:%x\n", sceneId);
 464
 465         return 0;
 466 }
 467
 468 /*********************************************************************
 469  * @fn          uint8_t SRPC_identifyDevice(uint8_t *pBuf, uint32_t clientFd)
 470  *
 471  * @brief       This function exposes an interface to make a device identify.
 472  *
 473  * @param       pBuf - incomin messages
 474  *
 475  * @return      afStatus_t
 476  */
 477 static uint8_t SRPC_identifyDevice(uint8_t *pBuf, uint32_t clientFd)
 478 {
 479         uint8_t endpoint, addrMode;
 480         uint16_t dstAddr;
 481         uint16_t identifyTime;
 482
 483         //printf("SRPC_identifyDevice++\n");
 484
 485         //increment past SRPC header
 486         pBuf += 2;
 487
 488         addrMode = (afAddrMode_t) *pBuf++;
 489         dstAddr = BUILD_UINT16(pBuf[0], pBuf[1]);
 490         pBuf += Z_EXTADDR_LEN;
 491         endpoint = *pBuf++;
 492         // index past panId
 493         pBuf += 2;
 494
 495         identifyTime = BUILD_UINT16(pBuf[0], pBuf[1]);
 496         pBuf += 2;
 497
 498         zbSocSendIdentify(identifyTime, dstAddr, endpoint, addrMode);
 499
 500         return 0;
 501 }
 502
 503 /*********************************************************************
 504  * @fn          SRPC_bindDevices
 505  *
 506  * @brief       This function exposes an interface to set a bind devices.
 507  *
 508  * @param       pBuf - incomin messages
 509  *
 510  * @return      afStatus_t
 511  */
 512 uint8_t SRPC_bindDevices(uint8_t *pBuf, uint32_t clientFd)
 513 {
 514         uint16_t srcNwkAddr;
 515         uint8_t srcEndpoint;
 516         uint8 srcIEEE[8];
 517         uint8_t dstEndpoint;
 518         uint8 dstIEEE[8];
 519         uint16 clusterId;
 520
 521         //printf("SRPC_bindDevices++\n");
 522
 523         //increment past SRPC header
 524         pBuf += 2;
 525
 526         /* Src Address */
 527         srcNwkAddr = BUILD_UINT16( pBuf[0], pBuf[1] );
 528         pBuf += 2;
 529
 530         srcEndpoint = *pBuf++;
 531
 532         memcpy(srcIEEE, pBuf, Z_EXTADDR_LEN);
 533         pBuf += Z_EXTADDR_LEN;
 534
 535         dstEndpoint = *pBuf++;
 536
 537         memcpy(dstIEEE, pBuf, Z_EXTADDR_LEN);
 538         pBuf += Z_EXTADDR_LEN;
 539
 540         clusterId = BUILD_UINT16(pBuf[0], pBuf[1]);
 541         pBuf += 2;
 542
 543         zbSocBind(srcNwkAddr, srcEndpoint, srcIEEE, dstEndpoint, dstIEEE, clusterId);
 544
 545         return 0;
 546 }
 547
 548 /*********************************************************************
 549  * @fn          SRPC_setDeviceState
 550  *
 551  * @brief       This function exposes an interface to set a devices on/off attribute.
 552  *
 553  * @param       pBuf - incomin messages
 554  *
 555  * @return      afStatus_t
 556  */
 557 static uint8_t SRPC_setDeviceState(uint8_t *pBuf, uint32_t clientFd)
 558 {
 559         uint8_t endpoint, addrMode;
 560         uint16_t dstAddr;
 561         bool state;
 562
 563         //printf("SRPC_setDeviceState++\n");
 564
 565         //increment past SRPC header
 566         pBuf += 2;
 567
 568         addrMode = (afAddrMode_t) *pBuf++;
 569         dstAddr = BUILD_UINT16(pBuf[0], pBuf[1]);
 570         pBuf += Z_EXTADDR_LEN;
 571         endpoint = *pBuf++;
 572         // index past panId
 573         pBuf += 2;
 574
 575         state = (bool) *pBuf;
 576
 577         //printf("SRPC_setDeviceState: dstAddr.addr.shortAddr=%x, endpoint=%x dstAddr.mode=%x, state=%x\n", dstAddr, endpoint, addrMode, state);
 578
 579         // Set light state on/off
 580         zbSocSetState(state, dstAddr, endpoint, addrMode);
 581
 582         //printf("SRPC_setDeviceState--\n");
 583
 584         return 0;
 585 }
 586
 587 /*********************************************************************
 588  * @fn          SRPC_setDeviceLevel
 589  *
 590  * @brief       This function exposes an interface to set a devices level attribute.
 591  *
 592  * @param       pBuf - incomin messages
 593  *
 594  * @return      afStatus_t
 595  */
 596 static uint8_t SRPC_setDeviceLevel(uint8_t *pBuf, uint32_t clientFd)
 597 {
 598         uint8_t endpoint, addrMode;
 599         uint16_t dstAddr;
 600         uint8_t level;
 601         uint16_t transitionTime;
 602
 603         //printf("SRPC_setDeviceLevel++\n");
 604
 605         //increment past SRPC header
 606         pBuf += 2;
 607
 608         addrMode = (afAddrMode_t) *pBuf++;
 609         dstAddr = BUILD_UINT16(pBuf[0], pBuf[1]);
 610         pBuf += Z_EXTADDR_LEN;
 611         endpoint = *pBuf++;
 612         // index past panId
 613         pBuf += 2;
 614
 615         level = *pBuf++;
 616
 617         transitionTime = BUILD_UINT16(pBuf[0], pBuf[1]);
 618         pBuf += 2;
 619
 620         //printf("SRPC_setDeviceLevel: dstAddr.addr.shortAddr=%x ,level=%x, tr=%x \n", dstAddr, level, transitionTime);
 621
 622         zbSocSetLevel(level, transitionTime, dstAddr, endpoint, addrMode);
 623
 624         //printf("SRPC_setDeviceLevel--\n");
 625
 626         return 0;
 627 }
 628
 629 /*********************************************************************
 630  * @fn          SRPC_setDeviceColor
 631  *
 632  * @brief       This function exposes an interface to set a devices hue and saturation attribute.
 633  *
 634  * @param       pBuf - incomin messages
 635  *
 636  * @return      afStatus_t
 637  */
 638 static uint8_t SRPC_setDeviceColor(uint8_t *pBuf, uint32_t clientFd)
 639 {
 640         uint8_t endpoint, addrMode;
 641         uint16_t dstAddr;
 642         uint8_t hue, saturation;
 643         uint16_t transitionTime;
 644
 645         //printf("SRPC_setDeviceColor++\n");
 646
 647         //increment past SRPC header
 648         pBuf += 2;
 649
 650         addrMode = (afAddrMode_t) *pBuf++;
 651         dstAddr = BUILD_UINT16(pBuf[0], pBuf[1]);
 652         pBuf += Z_EXTADDR_LEN;
 653         endpoint = *pBuf++;
 654         // index past panId
 655         pBuf += 2;
 656
 657         hue = *pBuf++;
 658
 659         saturation = *pBuf++;
 660
 661         transitionTime = BUILD_UINT16(pBuf[0], pBuf[1]);
 662         pBuf += 2;
 663
 664 //  printf("SRPC_setDeviceColor: dstAddr=%x ,hue=%x, saturation=%x, tr=%x \n", dstAddr, hue, saturation, transitionTime);
 665
 666         zbSocSetHueSat(hue, saturation, transitionTime, dstAddr, endpoint, addrMode);
 667
 668         //printf("SRPC_setDeviceColor--\n");
 669
 670         return 0;
 671 }
 672
 673 /*********************************************************************
 674  * @fn          SRPC_getDeviceState
 675  *
 676  * @brief       This function exposes an interface to get a devices on/off attribute.
 677  *
 678  * @param       pBuf - incomin messages
 679  *
 680  * @return      afStatus_t
 681  */
 682 static uint8_t SRPC_getDeviceState(uint8_t *pBuf, uint32_t clientFd)
 683 {
 684         uint8_t endpoint, addrMode;
 685         uint16_t dstAddr;
 686
 687         //printf("SRPC_getDeviceState++\n");
 688
 689         //increment past SRPC header
 690         pBuf += 2;
 691
 692         addrMode = (afAddrMode_t) *pBuf++;
 693         dstAddr = BUILD_UINT16(pBuf[0], pBuf[1]);
 694         pBuf += Z_EXTADDR_LEN;
 695         endpoint = *pBuf++;
 696         // index past panId
 697         pBuf += 2;
 698
 699         //printf("SRPC_getDeviceState: dstAddr.addr.shortAddr=%x, endpoint=%x dstAddr.mode=%x", dstAddr, endpoint, addrMode);
 700
 701         // Get light state on/off
 702         zbSocGetState(dstAddr, endpoint, addrMode);
 703
 704         //printf("SRPC_getDeviceState--\n");
 705
 706         return 0;
 707 }
 708
 709 /*********************************************************************
 710  * @fn          SRPC_getDeviceLevel
 711  *
 712  * @brief       This function exposes an interface to get a devices level attribute.
 713  *
 714  * @param       pBuf - incomin messages
 715  *
 716  * @return      afStatus_t
 717  */
 718 static uint8_t SRPC_getDeviceLevel(uint8_t *pBuf, uint32_t clientFd)
 719 {
 720         uint8_t endpoint, addrMode;
 721         uint16_t dstAddr;
 722
 723         //printf("SRPC_getDeviceLevel++\n");
 724
 725         //increment past SRPC header
 726         pBuf += 2;
 727
 728         addrMode = (afAddrMode_t) *pBuf++;
 729         dstAddr = BUILD_UINT16(pBuf[0], pBuf[1]);
 730         pBuf += Z_EXTADDR_LEN;
 731         endpoint = *pBuf++;
 732         // index past panId
 733         pBuf += 2;
 734
 735         //printf("SRPC_getDeviceLevel: dstAddr.addr.shortAddr=%x, endpoint=%x dstAddr.mode=%x\n", dstAddr, endpoint, addrMode);
 736
 737         // Get light level
 738         zbSocGetLevel(dstAddr, endpoint, addrMode);
 739
 740         //printf("SRPC_getDeviceLevel--\n");
 741
 742         return 0;
 743 }
 744
 745 /*********************************************************************
 746  * @fn          SRPC_getDeviceHue
 747  *
 748  * @brief       This function exposes an interface to get a devices hue attribute.
 749  *
 750  * @param       pBuf - incomin messages
 751  *
 752  * @return      afStatus_t
 753  */
 754 static uint8_t SRPC_getDeviceHue(uint8_t *pBuf, uint32_t clientFd)
 755 {
 756         uint8_t endpoint, addrMode;
 757         uint16_t dstAddr;
 758
 759         //printf("SRPC_getDeviceHue++\n");
 760
 761         //increment past SRPC header
 762         pBuf += 2;
 763
 764         addrMode = (afAddrMode_t) *pBuf++;
 765         dstAddr = BUILD_UINT16(pBuf[0], pBuf[1]);
 766         pBuf += Z_EXTADDR_LEN;
 767         endpoint = *pBuf++;
 768         // index past panId
 769         pBuf += 2;
 770
 771         //printf("SRPC_getDeviceHue: dstAddr.addr.shortAddr=%x, endpoint=%x dstAddr.mode=%x\n", dstAddr, endpoint, addrMode);
 772
 773         // Get light hue
 774         zbSocGetHue(dstAddr, endpoint, addrMode);
 775
 776         //printf("SRPC_getDeviceHue--\n");
 777
 778         return 0;
 779 }
 780
 781 /*********************************************************************
 782  * @fn          SRPC_getDeviceSat
 783  *
 784  * @brief       This function exposes an interface to get a devices sat attribute.
 785  *
 786  * @param       pBuf - incomin messages
 787  *
 788  * @return      afStatus_t
 789  */
 790 static uint8_t SRPC_getDeviceSat(uint8_t *pBuf, uint32_t clientFd)
 791 {
 792         uint8_t endpoint, addrMode;
 793         uint16_t dstAddr;
 794
 795         //printf("SRPC_getDeviceSat++\n");
 796
 797         //increment past SRPC header
 798         pBuf += 2;
 799
 800         addrMode = (afAddrMode_t) *pBuf++;
 801         dstAddr = BUILD_UINT16(pBuf[0], pBuf[1]);
 802         pBuf += Z_EXTADDR_LEN;
 803         endpoint = *pBuf++;
 804         // index past panId
 805         pBuf += 2;
 806
 807         //printf("SRPC_getDeviceSat: dstAddr.addr.shortAddr=%x, endpoint=%x dstAddr.mode=%x\n", dstAddr, endpoint, addrMode);
 808
 809         // Get light sat
 810         zbSocGetSat(dstAddr, endpoint, addrMode);
 811
 812         //printf("SRPC_getDeviceSat--\n");
 813
 814         return 0;
 815 }
 816
 817 /*********************************************************************
 818  * @fn          SRPC_changeDeviceName
 819  *
 820  * @brief       This function exposes an interface to set a bind devices.
 821  *
 822  * @param       pBuf - incomin messages
 823  *
 824  * @return      afStatus_t
 825  */
 826 static uint8_t SRPC_changeDeviceName(uint8_t *pBuf, uint32_t clientFd)
 827 {
 828         uint16_t devNwkAddr;
 829         uint8_t devEndpoint;
 830         uint8_t nameLen;
 831         epInfo_t * epInfo;
 832
 833         printf("RSPC_ZLL_changeDeviceName++\n");
 834
 835         //increment past SRPC header
 836         pBuf += 2;
 837
 838         // Src Address
 839         devNwkAddr = BUILD_UINT16( pBuf[0], pBuf[1] );
 840         pBuf += 2;
 841
 842         devEndpoint = *pBuf++;
 843
 844         nameLen = *pBuf++;
 845         if (nameLen > MAX_SUPPORTED_DEVICE_NAME_LENGTH)
 846         {
 847                 nameLen = MAX_SUPPORTED_DEVICE_NAME_LENGTH;
 848         }
 849
 850         printf("RSPC_ZLL_changeDeviceName: renaming device %s, len=%d\n", pBuf,
 851                         nameLen);
 852         printf("RSPC_ZLL_changeDeviceName: devNwkAddr=%x, devEndpoint=%x\n",
 853                         devNwkAddr, devEndpoint);
 854
 855         epInfo = devListRemoveDeviceByNaEp(devNwkAddr, devEndpoint);
 856         if (epInfo != NULL)
 857         {
 858                 /*
 859                  if(epInfo->deviceName != NULL)
 860                  {
 861                  free(epInfo->deviceName);
 862                  }*/
 863                 epInfo->deviceName = malloc(nameLen + 1);
 864                 printf("RSPC_ZLL_changeDeviceName: renamed device %s, len=%d\n", pBuf,
 865                                 nameLen);
 866                 strncpy(epInfo->deviceName, (char *) pBuf, nameLen);
 867                 epInfo->deviceName[nameLen] = '\0';
 868                 devListAddDevice(epInfo);
 869         }
 870
 871         return 0;
 872 }
 873
 874 /*********************************************************************
 875  * @fn          SRPC_close
 876  *
 877  * @brief       This function exposes an interface to allow an upper layer to close the interface.
 878  *
 879  * @param       pBuf - incomin messages
 880  *
 881  * @return      afStatus_t
 882  */
 883 uint8_t SRPC_close(uint8_t *pBuf, uint32_t clientFd)
 884 {
 885         uint16_t magicNumber;
 886
 887         //printf("SRPC_close++\n");
 888
 889         //increment past SRPC header
 890         pBuf += 2;
 891
 892         magicNumber = BUILD_UINT16(pBuf[0], pBuf[1]);
 893
 894         if (magicNumber == CLOSE_AUTH_NUM)
 895         {
 896                 //Close the application
 897                 socketSeverClose();
 898                 //TODO: Need to create API's and close other fd's
 899
 900                 exit(EXIT_SUCCESS);
 901         }
 902
 903         return 0;
 904 }
 905
 906 /*********************************************************************
 907  * @fn          uint8_t SRPC_permitJoin(uint8_t *pBuf, uint32_t clientFd)
 908  *
 909  * @brief       This function exposes an interface to permit other devices to join the network.
 910  *
 911  * @param       pBuf - incomin messages
 912  *
 913  * @return      none
 914  */
 915 static uint8_t SRPC_permitJoin(uint8_t *pBuf, uint32_t clientFd)
 916 {
 917         uint8_t duration;
 918         uint16_t magicNumber;
 919
 920         //increment past SRPC header
 921         pBuf += 2;
 922
 923         duration = *pBuf++;
 924         magicNumber = BUILD_UINT16(pBuf[0], pBuf[1]);
 925
 926         if (magicNumber == JOIN_AUTH_NUM)
 927         {
 928                 //Open the network for joining
 929                 zbSocOpenNwk(duration);
 930         }
 931
 932         return 0;
 933 }
 934
 935 /*********************************************************************
 936  * @fn          uint8_t SRPC_getGroups(uint8_t *pBuf, uint32_t clientFd)
 937  *
 938  * @brief       This function exposes an interface to get the group list.
 939  *
 940  * @param       pBuf - incomin messages
 941  *
 942  * @return      none
 943  */
 944 static uint8_t SRPC_getGroups(uint8_t *pBuf, uint32_t clientFd)
 945 {
 946         uint32_t context = 0;
 947         groupRecord_t *group = groupListGetNextGroup(&context);
 948         uint8_t nameLen, nameIdx;
 949
 950         //printf("SRPC_getGroups++\n");
 951
 952         while (group != NULL)
 953         {
 954                 uint8_t *pSrpcMessage, *pBuf;
 955                 //printf("SRPC_getGroups: group != null\n");
 956
 957                 //printf("SRPC_getGroups: malloc'ing %d bytes\n", (2 + (sizeof(uint16_t)) + ((uint8_t) (group->groupNameStr[0]))));
 958
 959                 //RpcMessage contains function ID param Data Len and param data
 960                 //2 (SRPC header) + sizeof(uint16_t) (GroupId) + sizeof(uint8_t) (GroupName Len) + group->groupNameStr[0] (string)
 961                 pSrpcMessage = malloc(
 962                                 2 + (sizeof(uint16_t)) + sizeof(uint8_t) + ((uint8_t)(group->name[0])));
 963
 964                 pBuf = pSrpcMessage;
 965
 966                 //Set func ID in RPCS buffer
 967                 *pBuf++ = SRPC_GET_GROUP_RSP;
 968                 //param size
 969                 //sizeof(uint16_t) (GroupId) + sizeof(uint8_t) (SceneId) + sizeof(uint8_t) (GroupName Len) + group->groupNameStr[0] (string)
 970                 *pBuf++ = (sizeof(uint16_t) + sizeof(uint8_t) + group->name[0]);
 971
 972                 *pBuf++ = group->id & 0xFF;
 973                 *pBuf++ = (group->id & 0xFF00) >> 8;
 974
 975                 nameLen = strlen(group->name);
 976                 if (nameLen > 0)
 977                 {
 978                         *pBuf++ = nameLen;
 979                         for (nameIdx = 0; nameIdx < nameLen; nameIdx++)
 980                         {
 981                                 *pBuf++ = group->name[nameIdx];
 982                         }
 983                         printf("SRPC_getGroups: name:%s\n", group->name);
 984                 }
 985                 else
 986                 {
 987                         *pBuf++ = 0;
 988                 }
 989
 990                 //printf("SRPC_CallBack_addGroupRsp: groupName[%d] %s\n", group->groupNameStr[0], &(group->groupNameStr[1]));
 991                 //Send SRPC
 992                 srpcSend(pSrpcMessage, clientFd);
 993                 free(pSrpcMessage);
 994                 //get next group (NULL if all done)
 995                 group = groupListGetNextGroup(&context);
 996         }
 997         //printf("SRPC_getGroups--\n");
 998
 999         return 0;
1000 }
1001
1002 /***************************************************************************************************
1003  * @fn      SRPC_CallBack_addGroupRsp
1004  *
1005  * @brief   Sends the groupId to the client after a groupAdd
1006  *
1007  * @return  Status
1008  ***************************************************************************************************/
1009 void SRPC_CallBack_addGroupRsp(uint16_t groupId, char *nameStr,
1010                 uint32_t clientFd)
1011 {
1012         uint8_t *pSrpcMessage, *pBuf;
1013
1014         //printf("SRPC_CallBack_addGroupRsp++\n");
1015
1016         //printf("SRPC_CallBack_addGroupRsp: malloc'ing %d bytes\n", 2 + 3 + nameStr[0]);
1017         //RpcMessage contains function ID param Data Len and param data
1018         pSrpcMessage = malloc(2 + 3 + strlen(nameStr));
1019
1020         pBuf = pSrpcMessage;
1021
1022         //Set func ID in SRPC buffer
1023         *pBuf++ = SRPC_ADD_GROUP_RSP;
1024         //param size
1025         *pBuf++ = 3 + strlen(nameStr);
1026
1027         *pBuf++ = groupId & 0xFF;
1028         *pBuf++ = (groupId & 0xFF00) >> 8;
1029
1030         *pBuf++ = strlen(nameStr);
1031         int i;
1032         for (i = 0; i < strlen(nameStr); i++)
1033         {
1034                 *pBuf++ = nameStr[i];
1035         }
1036
1037         printf("SRPC_CallBack_addGroupRsp: groupName[%d] %s\n", strlen(nameStr),
1038                         nameStr);
1039         //Send SRPC
1040         srpcSend(pSrpcMessage, clientFd);
1041
1042         //printf("SRPC_CallBack_addGroupRsp--\n");
1043
1044         return;
1045 }
1046
1047 /*********************************************************************
1048  * @fn          uint8_t SRPC_getScenes(uint8_t *pBuf, uint32_t clientFd)
1049  *
1050  * @brief       This function exposes an interface to get the scenes defined for a group.
1051  *
1052  * @param       pBuf - incomin messages
1053  *
1054  * @return      afStatus_t
1055  */
1056 static uint8_t SRPC_getScenes(uint8_t *pBuf, uint32_t clientFd)
1057 {
1058         uint32_t context = 0;
1059         sceneRecord_t *scene = sceneListGetNextScene(&context);
1060         uint8_t nameLen, nameIdx;
1061
1062         //printf("SRPC_getScenes++\n");
1063
1064         while (scene != NULL)
1065         {
1066                 uint8_t *pSrpcMessage, *pBuf;
1067                 //printf("SRPC_getScenes: scene != null\n");
1068
1069                 //printf("SRPC_getScenes: malloc'ing %d bytes\n", (2 + (sizeof(uint16_t)) + (sizeof(uint8_t)) + (sizeof(uint8_t)) + ((uint8_t) (scene->sceneNameStr[0]))));
1070
1071                 //RpcMessage contains function ID param Data Len and param data
1072                 //2 (SRPC header) + sizeof(uint16_t) (GroupId) + sizeof(uint8_t) (SceneId) + sizeof(uint8_t) (SceneName Len) + scene->sceneNameStr[0] (string)
1073                 pSrpcMessage = malloc(
1074                                 2 + (sizeof(uint16_t)) + (sizeof(uint8_t)) + (sizeof(uint8_t))
1075                                                 + ((uint8_t)(scene->name[0])));
1076
1077                 pBuf = pSrpcMessage;
1078
1079                 //Set func ID in RPCS buffer
1080                 *pBuf++ = SRPC_GET_SCENE_RSP;
1081                 //param size
1082                 //sizeof(uint16_t) (GroupId) + sizeof(uint8_t) (SceneId) + sizeof(uint8_t) (SceneName Len) + scene->sceneNameStr[0] (string)
1083                 *pBuf++ = (sizeof(uint16_t) + (sizeof(uint8_t)) + (sizeof(uint8_t))
1084                                 + scene->name[0]);
1085
1086                 *pBuf++ = scene->groupId & 0xFF;
1087                 *pBuf++ = (scene->groupId & 0xFF00) >> 8;
1088
1089                 *pBuf++ = scene->sceneId;
1090
1091                 nameLen = strlen(scene->name);
1092                 if (nameLen > 0)
1093                 {
1094                         *pBuf++ = nameLen;
1095                         for (nameIdx = 0; nameIdx < nameLen; nameIdx++)
1096                         {
1097                                 *pBuf++ = scene->name[nameIdx];
1098                         }
1099                         printf("SRPC_getScenes: name:%s\n", scene->name);
1100                 }
1101                 else
1102                 {
1103                         *pBuf++ = 0;
1104                 }
1105
1106                 //printf("SRPC_getScenes: sceneName[%d] %s, groupId %x\n", scene->sceneNameStr[0], &(scene->sceneNameStr[1]), scene->groupId);
1107                 //Send SRPC
1108                 srpcSend(pSrpcMessage, clientFd);
1109                 free(pSrpcMessage);
1110                 //get next scene (NULL if all done)
1111                 scene = sceneListGetNextScene(&context);
1112         }
1113         //printf("SRPC_getScenes--\n");
1114
1115         return 0;
1116 }
1117
1118 /***************************************************************************************************
1119  * @fn      SRPC_CallBack_addSceneRsp
1120  *
1121  * @brief   Sends the sceneId to the client after a storeScene
1122  *
1123  * @return  Status
1124  ***************************************************************************************************/
1125 void SRPC_CallBack_addSceneRsp(uint16_t groupId, uint8_t sceneId, char *nameStr,
1126                 uint32_t clientFd)
1127 {
1128         uint8_t *pSrpcMessage, *pBuf;
1129
1130         //printf("SRPC_CallBack_addSceneRsp++\n");
1131
1132         //printf("SRPC_CallBack_addSceneRsp: malloc'ing %d bytes\n", 2 + 4 + nameStr[0]);
1133         //RpcMessage contains function ID param Data Len and param data
1134         pSrpcMessage = malloc(2 + 4 + nameStr[0]);
1135
1136         pBuf = pSrpcMessage;
1137
1138         //Set func ID in SRPC buffer
1139         *pBuf++ = SRPC_ADD_SCENE_RSP;
1140         //param size
1141         *pBuf++ = 4 + nameStr[0];
1142
1143         *pBuf++ = groupId & 0xFF;
1144         *pBuf++ = (groupId & 0xFF00) >> 8;
1145
1146         *pBuf++ = sceneId & 0xFF;
1147
1148         *pBuf++ = nameStr[0];
1149         int i;
1150         for (i = 0; i < nameStr[0]; i++)
1151         {
1152                 *pBuf++ = nameStr[i + 1];
1153         }
1154
1155         //printf("SRPC_CallBack_addSceneRsp: groupName[%d] %s\n", nameStr[0], nameStr);
1156         //Send SRPC
1157         srpcSend(pSrpcMessage, clientFd);
1158
1159         //printf("SRPC_CallBack_addSceneRsp--\n");
1160
1161         return;
1162 }
1163
1164 /***************************************************************************************************
1165  * @fn      SRPC_CallBack_getStateRsp
1166  *
1167  * @brief   Sends the get State Rsp to the client that sent a get state
1168  *
1169  * @return  Status
1170  ***************************************************************************************************/
1171 void SRPC_CallBack_getStateRsp(uint8_t state, uint16_t srcAddr,
1172                 uint8_t endpoint, uint32_t clientFd)
1173 {
1174         uint8_t * pBuf;
1175         uint8_t pSrpcMessage[2 + 4];
1176
1177         //printf("SRPC_CallBack_getStateRsp++\n");
1178
1179         //RpcMessage contains function ID param Data Len and param data
1180
1181         pBuf = pSrpcMessage;
1182
1183         //Set func ID in RPCS buffer
1184         *pBuf++ = SRPC_GET_DEV_STATE_RSP;
1185         //param size
1186         *pBuf++ = 4;
1187
1188         *pBuf++ = srcAddr & 0xFF;
1189         *pBuf++ = (srcAddr & 0xFF00) >> 8;
1190         *pBuf++ = endpoint;
1191         *pBuf++ = state & 0xFF;
1192
1193         //printf("SRPC_CallBack_getStateRsp: state=%x\n", state);
1194
1195         //Store the device that sent the request, for now send to all clients
1196         srpcSendAll(pSrpcMessage);
1197
1198         //printf("SRPC_CallBack_addSceneRsp--\n");
1199
1200         return;
1201 }
1202
1203 /***************************************************************************************************
1204  * @fn      SRPC_CallBack_getLevelRsp
1205  *
1206  * @brief   Sends the get Level Rsp to the client that sent a get level
1207  *
1208  * @return  Status
1209  ***************************************************************************************************/
1210 void SRPC_CallBack_getLevelRsp(uint8_t level, uint16_t srcAddr,
1211                 uint8_t endpoint, uint32_t clientFd)
1212 {
1213         uint8_t * pBuf;
1214         uint8_t pSrpcMessage[2 + 4];
1215
1216         //printf("SRPC_CallBack_getLevelRsp++\n");
1217
1218         //RpcMessage contains function ID param Data Len and param data
1219
1220         pBuf = pSrpcMessage;
1221
1222         //Set func ID in RPCS buffer
1223         *pBuf++ = SRPC_GET_DEV_LEVEL_RSP;
1224         //param size
1225         *pBuf++ = 4;
1226
1227         *pBuf++ = srcAddr & 0xFF;
1228         *pBuf++ = (srcAddr & 0xFF00) >> 8;
1229         *pBuf++ = endpoint;
1230         *pBuf++ = level & 0xFF;
1231
1232         //printf("SRPC_CallBack_getLevelRsp: level=%x\n", level);
1233
1234         //Store the device that sent the request, for now send to all clients
1235         srpcSendAll(pSrpcMessage);
1236
1237         //printf("SRPC_CallBack_getLevelRsp--\n");
1238
1239         return;
1240 }
1241
1242 /***************************************************************************************************
1243  * @fn      SRPC_CallBack_getHueRsp
1244  *
1245  * @brief   Sends the get Hue Rsp to the client that sent a get hue
1246  *
1247  * @return  Status
1248  ***************************************************************************************************/
1249 void SRPC_CallBack_getHueRsp(uint8_t hue, uint16_t srcAddr, uint8_t endpoint,
1250                 uint32_t clientFd)
1251 {
1252         uint8_t * pBuf;
1253         uint8_t pSrpcMessage[2 + 4];
1254
1255         //printf("SRPC_CallBack_getLevelRsp++\n");
1256
1257         //RpcMessage contains function ID param Data Len and param data
1258
1259         pBuf = pSrpcMessage;
1260
1261         //Set func ID in RPCS buffer
1262         *pBuf++ = SRPC_GET_DEV_HUE_RSP;
1263         //param size
1264         *pBuf++ = 4;
1265
1266         *pBuf++ = srcAddr & 0xFF;
1267         *pBuf++ = (srcAddr & 0xFF00) >> 8;
1268         *pBuf++ = endpoint;
1269         *pBuf++ = hue & 0xFF;
1270
1271         //printf("SRPC_CallBack_getHueRsp: hue=%x\n", hue);
1272
1273         //Store the device that sent the request, for now send to all clients
1274         srpcSendAll(pSrpcMessage);
1275
1276         //printf("SRPC_CallBack_getHueRsp--\n");
1277
1278         return;
1279 }
1280
1281 /***************************************************************************************************
1282  * @fn      SRPC_CallBack_getSatRsp
1283  *
1284  * @brief   Sends the get Sat Rsp to the client that sent a get sat
1285  *
1286  * @return  Status
1287  ***************************************************************************************************/
1288 void SRPC_CallBack_getSatRsp(uint8_t sat, uint16_t srcAddr, uint8_t endpoint,
1289                 uint32_t clientFd)
1290 {
1291         uint8_t * pBuf;
1292         uint8_t pSrpcMessage[2 + 4];
1293
1294         //printf("SRPC_CallBack_getSatRsp++\n");
1295
1296         //RpcMessage contains function ID param Data Len and param data
1297
1298         pBuf = pSrpcMessage;
1299
1300         //Set func ID in RPCS buffer
1301         *pBuf++ = SRPC_GET_DEV_SAT_RSP;
1302         //param size
1303         *pBuf++ = 4;
1304
1305         *pBuf++ = srcAddr & 0xFF;
1306         *pBuf++ = (srcAddr & 0xFF00) >> 8;
1307         *pBuf++ = endpoint;
1308         *pBuf++ = sat & 0xFF;
1309
1310         //printf("SRPC_CallBack_getSatRsp: sat=%x\n", sat);
1311
1312         //Store the device that sent the request, for now send to all clients
1313         srpcSendAll(pSrpcMessage);
1314
1315         //printf("SRPC_CallBack_getSatRsp--\n");
1316
1317         return;
1318 }
1319
1320 void error(const char *msg)
1321 {
1322         perror(msg);
1323         exit(1);
1324 }
1325
1326 /*********************************************************************
1327  * @fn          SRPC_getDevices
1328  *
1329  * @brief       This function exposes an interface to allow an upper layer to start device discovery.
1330  *
1331  * @param       pBuf - incomin messages
1332  *
1333  * @return      afStatus_t
1334  */
1335 static uint8_t SRPC_getDevices(uint8_t *pBuf, uint32_t clientFd)
1336 {
1337         epInfoExtended_t epInfoEx;
1338         uint32_t context = 0;
1339         uint8_t *pSrpcMessage;
1340
1341         //printf("SRPC_getDevices++ \n");
1342
1343         while ((epInfoEx.epInfo = devListGetNextDev(&context)) != NULL)
1344         {
1345                 epInfoEx.type = EP_INFO_TYPE_EXISTING;
1346                 epInfoEx.prevNwkAddr = 0xFFFF;
1347                 epInfoEx.epInfo->flags = MT_NEW_DEVICE_FLAGS_NONE;
1348
1349                 //Send epInfo
1350                 pSrpcMessage = srpcParseEpInfo(&epInfoEx);
1351                 printf("SRPC_getDevices: %x:%x:%x:%x:%x\n", epInfoEx.epInfo->nwkAddr, epInfoEx.epInfo->endpoint,
1352                                 epInfoEx.epInfo->profileID, epInfoEx.epInfo->deviceID, epInfoEx.type);
1353                 //Send SRPC
1354                 srpcSend(pSrpcMessage, clientFd);
1355                 free(pSrpcMessage);
1356
1357                 usleep(1000);
1358
1359                 //get next device (NULL if all done)
1360 //printf("--?--> 0x%04X, 0x%02X", (uint32_t)epInfoEx.epInfo->nwkAddr, (uint32_t)epInfoEx.epInfo->endpoint);
1361 //printf(" --!--> 0x%08X\n", (uint32_t)epInfoEx.epInfo);
1362         }
1363
1364         return 0;
1365 }
1366
1367 /*********************************************************************
1368  * @fn          SRPC_notSupported
1369  *
1370  * @brief       This function is called for unsupported commands.
1371  *
1372  * @param       pBuf - incomin messages
1373  *
1374  * @return      afStatus_t
1375  */
1376 static uint8_t SRPC_notSupported(uint8_t *pBuf, uint32_t clientFd)
1377 {
1378         return 0;
1379 }
1380
1381 /***************************************************************************************************
1382  * @fn      SRPC_Init
1383  *
1384  * @brief   initialises the RPC interface and waitsfor a client to connect.
1385  * @param
1386  *
1387  * @return  Status
1388  ***************************************************************************************************/
1389 void SRPC_Init(void)
1390 {
1391         if (socketSeverInit(SRPC_TCP_PORT) == -1)
1392         {
1393                 //exit if the server does not start
1394                 exit(-1);
1395         }
1396
1397         serverSocketConfig(SRPC_RxCB, SRPC_ConnectCB);
1398 }
1399
1400 /*********************************************************************
1401  * @fn          SRPC_SendEpInfo
1402  *
1403  * @brief       This function exposes an interface to allow an upper layer to start send an ep indo to all devices.
1404  *
1405  * @param       epInfo - pointer to the epInfo to be sent
1406  *
1407  * @return      afStatus_t
1408  */
1409 uint8_t SRPC_SendEpInfo(epInfoExtended_t *epInfoEx)
1410 {
1411   uint8_t *pSrpcMessage = srpcParseEpInfo(epInfoEx);
1412
1413   printf("SRPC_SendEpInfo++ %x:%x:%x:%x\n", epInfoEx->epInfo->nwkAddr, epInfoEx->epInfo->endpoint, epInfoEx->epInfo->profileID, epInfoEx->epInfo->deviceID);
1414
1415   //Send SRPC
1416   srpcSendAll(pSrpcMessage);
1417   free(pSrpcMessage);
1418   printf("RSPC_SendEpInfo--\n");
1419
1420   return 0;
1421 }
1422
1423 /***************************************************************************************************
1424  * @fn      SRPC_ConnectCB
1425  *
1426  * @brief   Callback for connecting SRPC clients.
1427  *
1428  * @return  Status
1429  ***************************************************************************************************/
1430 void SRPC_ConnectCB(int clientFd)
1431 {
1432         //printf("SRPC_ConnectCB++ \n");
1433         /*
1434          epInfo = devListGetNextDev(0xFFFF, 0);
1435
1436          while(epInfo)
1437          {
1438          printf("SRPC_ConnectCB: send epInfo\n");
1439          //Send device Annce
1440          uint8_t *pSrpcMessage = srpcParseEpInfo(epInfo);
1441          //Send SRPC
1442          srpcSend(pSrpcMessage, clientFd);
1443          free(pSrpcMessage);
1444
1445          usleep(1000);
1446
1447          //get next device (NULL if all done)
1448          epInfo = devListGetNextDev(epInfo->nwkAddr, epInfo->endpoint);
1449          }
1450          */
1451         //printf("SRPC_ConnectCB--\n");
1452 }
1453
1454 /***************************************************************************************************
1455  * @fn      SRPC_RxCB
1456  *
1457  * @brief   Callback for Rx'ing SRPC messages.
1458  *
1459  * @return  Status
1460  ***************************************************************************************************/
1461 void SRPC_RxCB(int clientFd)
1462 {
1463         char buffer[256];
1464         int byteToRead;
1465         int byteRead;
1466         int rtn;
1467
1468         //printf("SRPC_RxCB++[%x]\n", clientFd);
1469
1470         rtn = ioctl(clientFd, FIONREAD, &byteToRead);
1471
1472         if (rtn != 0)
1473         {
1474                 printf("SRPC_RxCB: Socket error\n");
1475         }
1476
1477         while (byteToRead)
1478         {
1479                 bzero(buffer, 256);
1480                 byteRead = 0;
1481                 //Get the CMD-ID and Len
1482                 byteRead += read(clientFd, buffer, 2);
1483                 //Get the rest of the message
1484                 //printf("SRPC: reading %x byte message\n",buffer[SRPC_MSG_LEN]);
1485                 byteRead += read(clientFd, &buffer[2], buffer[SRPC_MSG_LEN]);
1486                 byteToRead -= byteRead;
1487                 if (byteRead < 0) error("SRPC ERROR: error reading from socket\n");
1488                 if (byteRead < buffer[SRPC_MSG_LEN])
1489                         error("SRPC ERROR: full message not read\n");
1490                 //printf("Read the message[%x]\n",byteRead);
1491                 SRPC_ProcessIncoming((uint8_t*) buffer, clientFd);
1492         }
1493
1494         //printf("SRPC_RxCB--\n");
1495
1496         return;
1497 }
1498
1499 /***************************************************************************************************
1500  * @fn      Closes the TCP port
1501  *
1502  * @brief   Send a message over SRPC.
1503  *
1504  * @return  Status
1505  ***************************************************************************************************/
1506 void SRPC_Close(void)
1507 {
1508         socketSeverClose();
1509 }
1510