resource/csdk/connectivity/src/ip_adapter/caipserver.c

   1 /* ****************************************************************
   2  *
   3  * Copyright 2014 Samsung Electronics All Rights Reserved.
   4  *
   5  *
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  ******************************************************************/
  20
  21 #ifndef __APPLE_USE_RFC_3542
  22 #define __APPLE_USE_RFC_3542 // for PKTINFO
  23 #endif
  24 #ifndef _GNU_SOURCE
  25 #define _GNU_SOURCE // for in6_pktinfo
  26 #endif
  27
  28 #include <sys/types.h>
  29 #if !defined(_WIN32)
  30 #include <sys/socket.h>
  31 #endif
  32
  33 #if defined(_WIN32)
  34 #include <assert.h>
  35 #include <winsock2.h>
  36 #include <ws2def.h>
  37 #include <mswsock.h>
  38 #include <ws2tcpip.h>
  39 #endif
  40
  41 #include <stdio.h>
  42 #include <unistd.h>
  43 #include <sys/types.h>
  44 #include <fcntl.h>
  45 #if !defined(_WIN32)
  46 #include <sys/select.h>
  47 #include <arpa/inet.h>
  48 #include <netinet/in.h>
  49 #include <net/if.h>
  50 #endif
  51 #include <errno.h>
  52 #ifdef __linux__
  53 #include <linux/netlink.h>
  54 #include <linux/rtnetlink.h>
  55 #endif
  56
  57 #include "pdu.h"
  58 #include "caipinterface.h"
  59 #include "caadapterutils.h"
  60 #ifdef __WITH_DTLS__
  61 #include "caadapternetdtls.h"
  62 #endif
  63 #include "camutex.h"
  64 #include "oic_malloc.h"
  65 #include "oic_string.h"
  66
  67 #define USE_IP_MREQN
  68 #if defined(_WIN32)
  69 #undef USE_IP_MREQN
  70 #endif
  71
  72 /*
  73  * Logging tag for module name
  74  */
  75 #define TAG "OIC_CA_IP_SERVER"
  76
  77 #define SELECT_TIMEOUT 1     // select() seconds (and termination latency)
  78
  79 #define IPv4_MULTICAST     "224.0.1.187"
  80 static struct in_addr IPv4MulticastAddress = { 0 };
  81
  82 #define IPv6_DOMAINS       16
  83 #define IPv6_MULTICAST_INT "ff01::fd"
  84 static struct in6_addr IPv6MulticastAddressInt;
  85 #define IPv6_MULTICAST_LNK "ff02::fd"
  86 static struct in6_addr IPv6MulticastAddressLnk;
  87 #define IPv6_MULTICAST_RLM "ff03::fd"
  88 static struct in6_addr IPv6MulticastAddressRlm;
  89 #define IPv6_MULTICAST_ADM "ff04::fd"
  90 static struct in6_addr IPv6MulticastAddressAdm;
  91 #define IPv6_MULTICAST_SIT "ff05::fd"
  92 static struct in6_addr IPv6MulticastAddressSit;
  93 #define IPv6_MULTICAST_ORG "ff08::fd"
  94 static struct in6_addr IPv6MulticastAddressOrg;
  95 #define IPv6_MULTICAST_GLB "ff0e::fd"
  96 static struct in6_addr IPv6MulticastAddressGlb;
  97
  98 static char *ipv6mcnames[IPv6_DOMAINS] = {
  99     NULL,
 100     IPv6_MULTICAST_INT,
 101     IPv6_MULTICAST_LNK,
 102     IPv6_MULTICAST_RLM,
 103     IPv6_MULTICAST_ADM,
 104     IPv6_MULTICAST_SIT,
 105     NULL,
 106     NULL,
 107     IPv6_MULTICAST_ORG,
 108     NULL,
 109     NULL,
 110     NULL,
 111     NULL,
 112     NULL,
 113     IPv6_MULTICAST_GLB,
 114     NULL
 115 };
 116
 117 #if defined (_WIN32)
 118 #define IFF_UP_RUNNING_FLAGS  (IFF_UP)
 119
 120     char* caips_get_error(){
 121         static char buffer[32];
 122         snprintf(buffer, 32, "%i", WSAGetLastError());
 123         return buffer;
 124     }
 125 #define CAIPS_GET_ERROR \
 126     caips_get_error()
 127 #else
 128 #define IFF_UP_RUNNING_FLAGS  (IFF_UP|IFF_RUNNING)
 129
 130 #define CAIPS_GET_ERROR \
 131     strerror(errno)
 132 #endif
 133 static CAIPExceptionCallback g_exceptionCallback;
 134
 135 static CAIPPacketReceivedCallback g_packetReceivedCallback;
 136
 137 static void CAHandleNetlink();
 138 static void CAFindReadyMessage();
 139 #if !defined(WSA_WAIT_EVENT_0)
 140 static void CASelectReturned(fd_set *readFds, int ret);
 141 #else
 142 static void CAEventReturned(HANDLE);
 143 #endif
 144 static void CAProcessNewInterface(CAInterface_t *ifchanged);
 145 static CAResult_t CAReceiveMessage(int fd, CATransportFlags_t flags);
 146
 147 static void CAReceiveHandler(void *data)
 148 {
 149     (void)data;
 150
 151     while (!caglobals.ip.terminate)
 152     {
 153         CAFindReadyMessage();
 154     }
 155 }
 156
 157 #if !defined(WSA_WAIT_EVENT_0)
 158
 159 #define CLOSE_SOCKET(TYPE) \
 160     if (caglobals.ip.TYPE.fd != -1) \
 161     { \
 162         close(caglobals.ip.TYPE.fd); \
 163         caglobals.ip.TYPE.fd = -1; \
 164     }
 165
 166 #define SET(TYPE, FDS) \
 167     if (caglobals.ip.TYPE.fd != -1) \
 168     { \
 169         FD_SET(caglobals.ip.TYPE.fd, FDS); \
 170     }
 171
 172 #define ISSET(TYPE, FDS, FLAGS) \
 173     if (caglobals.ip.TYPE.fd != -1 && FD_ISSET(caglobals.ip.TYPE.fd, FDS)) \
 174     { \
 175         fd = caglobals.ip.TYPE.fd; \
 176         flags = FLAGS; \
 177     }
 178
 179
 180 static void CAFindReadyMessage()
 181 {
 182     fd_set readFds;
 183     struct timeval timeout;
 184
 185     timeout.tv_sec = caglobals.ip.selectTimeout;
 186     timeout.tv_usec = 0;
 187     struct timeval *tv = caglobals.ip.selectTimeout == -1 ? NULL : &timeout;
 188
 189     FD_ZERO(&readFds);
 190     SET(u6,  &readFds)
 191     SET(u6s, &readFds)
 192     SET(u4,  &readFds)
 193     SET(u4s, &readFds)
 194     SET(m6,  &readFds)
 195     SET(m6s, &readFds)
 196     SET(m4,  &readFds)
 197     SET(m4s, &readFds)
 198
 199     if (caglobals.ip.shutdownFds[0] != -1)
 200     {
 201         FD_SET(caglobals.ip.shutdownFds[0], &readFds);
 202     }
 203     if (caglobals.ip.netlinkFd != -1)
 204     {
 205         FD_SET(caglobals.ip.netlinkFd, &readFds);
 206     }
 207
 208     int ret = select(caglobals.ip.maxfd + 1, &readFds, NULL, NULL, tv);
 209
 210     if (caglobals.ip.terminate)
 211     {
 212         OIC_LOG_V(DEBUG, TAG, "Packet receiver Stop request received.");
 213         return;
 214     }
 215
 216     if (ret <= 0)
 217     {
 218         if (ret < 0)
 219         {
 220             OIC_LOG_V(FATAL, TAG, "select error %s", CAIPS_GET_ERROR);
 221         }
 222         return;
 223     }
 224
 225     CASelectReturned(&readFds, ret);
 226 }
 227
 228 static void CASelectReturned(fd_set *readFds, int ret)
 229 {
 230     (void)ret;
 231     int fd = -1;
 232     CATransportFlags_t flags = CA_DEFAULT_FLAGS;
 233
 234     while (!caglobals.ip.terminate)
 235     {
 236         ISSET(u6,  readFds, CA_IPV6)
 237         else ISSET(u6s, readFds, CA_IPV6 | CA_SECURE)
 238         else ISSET(u4,  readFds, CA_IPV4)
 239         else ISSET(u4s, readFds, CA_IPV4 | CA_SECURE)
 240         else ISSET(m6,  readFds, CA_MULTICAST | CA_IPV6)
 241         else ISSET(m6s, readFds, CA_MULTICAST | CA_IPV6 | CA_SECURE)
 242         else ISSET(m4,  readFds, CA_MULTICAST | CA_IPV4)
 243         else ISSET(m4s, readFds, CA_MULTICAST | CA_IPV4 | CA_SECURE)
 244         else if ((caglobals.ip.netlinkFd != -1) && FD_ISSET(caglobals.ip.netlinkFd, readFds))
 245         {
 246             CAInterface_t *ifchanged = CAFindInterfaceChange();
 247             if (ifchanged)
 248             {
 249                 CAProcessNewInterface(ifchanged);
 250                 OICFree(ifchanged);
 251             }
 252             break;
 253         }
 254         else if (FD_ISSET(caglobals.ip.shutdownFds[0], readFds))
 255         {
 256             char buf[10] = {0};
 257             ssize_t len = read(caglobals.ip.shutdownFds[0], buf, sizeof (buf));
 258             if (-1 == len)
 259             {
 260                 continue;
 261             }
 262             break;
 263         }
 264         else
 265         {
 266             break;
 267         }
 268         (void)CAReceiveMessage(fd, flags);
 269         FD_CLR(fd, readFds);
 270     }
 271 }
 272
 273 #else // if defined(WSA_WAIT_EVENT_0)
 274
 275 #define CLOSE_SOCKET(TYPE) \
 276     if (caglobals.ip.TYPE.fd != -1) \
 277     { \
 278         closesocket(caglobals.ip.TYPE.fd); \
 279         caglobals.ip.TYPE.fd = -1; \
 280     }
 281
 282 #define PUSH_HANDLE(HANDLE, ARRAY, INDEX) \
 283 { \
 284     ARRAY[INDEX] = HANDLE; \
 285     INDEX++; \
 286 }
 287
 288 // Turn handle into WSAEvent and push to ARRAY
 289 #define PUSH_SOCKET(SOCKET, ARRAY, INDEX) \
 290     if (SOCKET != -1) \
 291     { \
 292         WSAEVENT NewEvent; \
 293         NewEvent = WSACreateEvent(); \
 294         if (WSA_INVALID_EVENT != NewEvent) \
 295         { \
 296             if (0 != WSAEventSelect(SOCKET, NewEvent, FD_READ)) \
 297             { \
 298                 OIC_LOG_V(ERROR, TAG, "WSAEventSelect failed 0x%08x ", WSAGetLastError()); \
 299                 if (!WSACloseEvent(NewEvent)) \
 300                 { \
 301                     OIC_LOG_V(ERROR, TAG, "WSACloseEvent(NewEvent) failed 0x%08x", WSAGetLastError()); \
 302                 } \
 303             } \
 304             else \
 305             { \
 306                 PUSH_HANDLE(NewEvent, ARRAY, INDEX); \
 307             } \
 308         } \
 309         else \
 310         { \
 311             OIC_LOG_V(ERROR, TAG, "WSACreateEvent(NewEvent) failed 0x%08x", WSAGetLastError()); \
 312         }\
 313     }
 314
 315 #define INSERT_FD(FD, ARRAY, INDEX) \
 316     { \
 317         if (-1 != FD) \
 318         { \
 319             ARRAY[INDEX] = FD; \
 320         } \
 321     }
 322
 323
 324 // Inserts the FD into the FD_ARRAY and pushes the socket event into ARRAY
 325 #define PUSH_IP_SOCKET(TYPE, ARRAY, FD_ARRAY, INDEX) \
 326     { \
 327         if (-1 != caglobals.ip.TYPE.fd) \
 328         { \
 329             INSERT_FD(caglobals.ip.TYPE.fd, FD_ARRAY, INDEX); \
 330             PUSH_SOCKET(caglobals.ip.TYPE.fd, ARRAY, INDEX); \
 331         } \
 332     }
 333
 334 #define IS_MATCHING_IP_HANDLE(TYPE, HANDLE, FLAGS) \
 335     if ((caglobals.ip.TYPE.fd != -1) && (caglobals.ip.TYPE.fd == HANDLE)) \
 336     { \
 337         fd = caglobals.ip.TYPE.fd; \
 338         flags = FLAGS; \
 339     }
 340
 341 #define EVENT_ARRAY_SIZE  10
 342
 343 static void CAFindReadyMessage()
 344 {
 345     int fdArray[EVENT_ARRAY_SIZE];
 346     HANDLE eventArray[EVENT_ARRAY_SIZE];
 347     int arraySize = 0;
 348     int eventIndex;
 349
 350     // fdArray and eventArray should have same number of elements
 351     /** @todo: replace with OC_STATIC_ASSERT */
 352     _Static_assert(_countof(fdArray) == _countof(eventArray), "Arrays should have same number of elements");
 353
 354     PUSH_IP_SOCKET(u6,  eventArray, fdArray, arraySize);
 355     PUSH_IP_SOCKET(u6s, eventArray, fdArray, arraySize);
 356     PUSH_IP_SOCKET(u4,  eventArray, fdArray, arraySize);
 357     PUSH_IP_SOCKET(u4s, eventArray, fdArray, arraySize);
 358     PUSH_IP_SOCKET(m6,  eventArray, fdArray, arraySize);
 359     PUSH_IP_SOCKET(m6s, eventArray, fdArray, arraySize);
 360     PUSH_IP_SOCKET(m4,  eventArray, fdArray, arraySize);
 361     PUSH_IP_SOCKET(m4s, eventArray, fdArray, arraySize);
 362
 363     if (-1 != caglobals.ip.shutdownEvent)
 364     {
 365         INSERT_FD(caglobals.ip.shutdownEvent, fdArray, arraySize);
 366         PUSH_HANDLE(caglobals.ip.shutdownEvent, eventArray, arraySize);
 367     }
 368
 369     /** @todo Support netlink events */
 370
 371     // Should not have overflowed buffer
 372     assert(arraySize <= (_countof(fdArray)));
 373
 374     // Timeout is unnecessary on Windows
 375     assert(-1 == caglobals.ip.selectTimeout);
 376
 377     while (!caglobals.ip.terminate)
 378     {
 379         int ret = WSAWaitForMultipleEvents(arraySize, eventArray, FALSE, WSA_INFINITE, FALSE);
 380
 381         switch (ret)
 382         {
 383             case WSA_WAIT_FAILED:
 384                 OIC_LOG_V(ERROR, TAG, "WSAWaitForMultipleEvents returned WSA_WAIT_FAILED 0x%08x", WSAGetLastError());
 385                 break;
 386             case WSA_WAIT_IO_COMPLETION:
 387                 OIC_LOG_V(ERROR, TAG, "WSAWaitForMultipleEvents returned WSA_WAIT_IO_COMPLETION 0x%08x", WSAGetLastError());
 388                 break;
 389             case WSA_WAIT_TIMEOUT:
 390                 OIC_LOG_V(ERROR, TAG, "WSAWaitForMultipleEvents returned WSA_WAIT_TIMEOUT 0x%08x", WSAGetLastError());
 391                 break;
 392             default:
 393                 eventIndex = ret - WSA_WAIT_EVENT_0;
 394                 if ((eventIndex >= 0) && (eventIndex < arraySize))
 395                 {
 396                     if (false == WSAResetEvent(eventArray[eventIndex]))
 397                     {
 398                         OIC_LOG_V(ERROR, TAG, "WSAResetEvent failed 0x%08x", WSAGetLastError());
 399                     }
 400                     CAEventReturned(fdArray[eventIndex]);
 401                 }
 402                 else
 403                 {
 404                     OIC_LOG_V(ERROR, TAG, "WSAWaitForMultipleEvents failed 0x%08x", WSAGetLastError());
 405                 }
 406                 break;
 407         }
 408
 409     }
 410
 411     while (arraySize > 0)
 412     {
 413         arraySize--;
 414         if (!WSACloseEvent(eventArray[arraySize]))
 415         {
 416             OIC_LOG_V(ERROR, TAG, "WSACloseEvent (Index %i) failed 0x%08x", arraySize, WSAGetLastError());
 417         }
 418     }
 419 }
 420
 421 static void CAEventReturned(HANDLE handle)
 422 {
 423     int fd = -1;
 424     CATransportFlags_t flags = CA_DEFAULT_FLAGS;
 425
 426     while (!caglobals.ip.terminate)
 427     {
 428         IS_MATCHING_IP_HANDLE(u6,  handle, CA_IPV6)
 429         else IS_MATCHING_IP_HANDLE(u6s, handle, CA_IPV6 | CA_SECURE)
 430         else IS_MATCHING_IP_HANDLE(u4,  handle, CA_IPV4)
 431         else IS_MATCHING_IP_HANDLE(u4s, handle, CA_IPV4 | CA_SECURE)
 432         else IS_MATCHING_IP_HANDLE(m6,  handle, CA_MULTICAST | CA_IPV6)
 433         else IS_MATCHING_IP_HANDLE(m6s, handle, CA_MULTICAST | CA_IPV6 | CA_SECURE)
 434         else IS_MATCHING_IP_HANDLE(m4,  handle, CA_MULTICAST | CA_IPV4)
 435         else IS_MATCHING_IP_HANDLE(m4s, handle, CA_MULTICAST | CA_IPV4 | CA_SECURE)
 436         else if ((caglobals.ip.shutdownEvent != -1) && (caglobals.ip.shutdownEvent == handle))
 437         {
 438             break;
 439         }
 440         else
 441         {
 442             break;
 443         }
 444         (void)CAReceiveMessage(handle, flags);
 445         // We will never get more than one match per handle, so always break.
 446         break;
 447     }
 448
 449     if (caglobals.ip.terminate)
 450     {
 451         if (-1 != caglobals.ip.shutdownEvent)
 452         {
 453             // We presume the shutdownEvent will be closed in CAFindReadyMessage
 454             caglobals.ip.shutdownEvent = -1;
 455             WSACleanup();
 456         }
 457     }
 458 }
 459
 460 #endif
 461
 462 void CADeInitializeIPGlobals()
 463 {
 464     CLOSE_SOCKET(u6);
 465     CLOSE_SOCKET(u6s);
 466     CLOSE_SOCKET(u4);
 467     CLOSE_SOCKET(u4s);
 468     CLOSE_SOCKET(m6);
 469     CLOSE_SOCKET(m6s);
 470     CLOSE_SOCKET(m4);
 471     CLOSE_SOCKET(m4s);
 472
 473     if (caglobals.ip.netlinkFd != -1)
 474     {
 475 #ifdef _WIN32
 476         closesocket(caglobals.ip.netlinkFd);
 477 #else
 478         close(caglobals.ip.netlinkFd);
 479 #endif
 480         caglobals.ip.netlinkFd = -1;
 481     }
 482 }
 483
 484 static CAResult_t CAReceiveMessage(int fd, CATransportFlags_t flags)
 485 {
 486     char recvBuffer[COAP_MAX_PDU_SIZE];
 487
 488     size_t len;
 489     int level, type, namelen;
 490     struct sockaddr_storage srcAddr;
 491     unsigned char *pktinfo = NULL;
 492 #if !defined(WSA_CMSG_DATA)
 493     struct cmsghdr *cmp = NULL;
 494     struct iovec iov = { .iov_base = recvBuffer, .iov_len = sizeof (recvBuffer) };
 495     union control
 496     {
 497         struct cmsghdr cmsg;
 498         unsigned char data[CMSG_SPACE(sizeof (struct in6_pktinfo))];
 499     } cmsg;
 500
 501     if (flags & CA_IPV6)
 502     {
 503         namelen = sizeof (struct sockaddr_in6);
 504         level = IPPROTO_IPV6;
 505         type = IPV6_PKTINFO;
 506         len = sizeof (struct in6_pktinfo);
 507     }
 508     else
 509     {
 510         namelen = sizeof (struct sockaddr_in);
 511         level = IPPROTO_IP;
 512         type = IP_PKTINFO;
 513         len = sizeof (struct in6_pktinfo);
 514     }
 515
 516     struct msghdr msg = { .msg_name = &srcAddr,
 517                           .msg_namelen = namelen,
 518                           .msg_iov = &iov,
 519                           .msg_iovlen = 1,
 520                           .msg_control = &cmsg,
 521                           .msg_controllen = CMSG_SPACE(len) };
 522
 523     ssize_t recvLen = recvmsg(fd, &msg, flags);
 524     if (-1 == recvLen)
 525     {
 526         OIC_LOG_V(ERROR, TAG, "Recvfrom failed %s", strerror(errno));
 527         return CA_STATUS_FAILED;
 528     }
 529
 530     if (flags & CA_MULTICAST)
 531     {
 532         for (cmp = CMSG_FIRSTHDR(&msg); cmp != NULL; cmp = CMSG_NXTHDR(&msg, cmp))
 533         {
 534             if (cmp->cmsg_level == level && cmp->cmsg_type == type)
 535             {
 536                 pktinfo = CMSG_DATA(cmp);
 537             }
 538         }
 539     }
 540 #else // if defined(WSA_CMSG_DATA)
 541     union control
 542     {
 543         WSACMSGHDR cmsg;
 544         uint8_t data[WSA_CMSG_SPACE(sizeof (IN6_PKTINFO))];
 545     } cmsg;
 546     memset(&cmsg, 0, sizeof(cmsg));
 547
 548     if (flags & CA_IPV6)
 549     {
 550         namelen  = sizeof (struct sockaddr_in6);
 551         level = IPPROTO_IPV6;
 552         type = IPV6_PKTINFO;
 553     }
 554     else
 555     {
 556         namelen = sizeof (struct sockaddr_in);
 557         level = IPPROTO_IP;
 558         type = IP_PKTINFO;
 559     }
 560
 561     WSABUF iov = {.len = sizeof (recvBuffer), .buf = recvBuffer};
 562     WSAMSG msg = {.name = &srcAddr,
 563                   .namelen = namelen,
 564                   .lpBuffers = &iov,
 565                   .dwBufferCount = 1,
 566                   .Control = {.buf = cmsg.data, .len = sizeof (cmsg)}
 567                  };
 568
 569     uint32_t recvLen = 0;
 570     uint32_t ret = caglobals.ip.wsaRecvMsg(fd, &msg, &recvLen, 0,0);
 571     OIC_LOG_V(DEBUG, TAG, "WSARecvMsg recvd %u bytes", recvLen);
 572     if (SOCKET_ERROR == ret)
 573     {
 574         OIC_LOG_V(ERROR, TAG, "WSARecvMsg failed %i", WSAGetLastError());
 575     }
 576
 577     if (flags & CA_MULTICAST)
 578     {
 579         for (WSACMSGHDR *cmp = WSA_CMSG_FIRSTHDR(&msg); cmp != NULL;
 580              cmp = WSA_CMSG_NXTHDR(&msg, cmp))
 581         {
 582             if (cmp->cmsg_level == level && cmp->cmsg_type == type)
 583             {
 584                 pktinfo = WSA_CMSG_DATA(cmp);
 585             }
 586         }
 587     }
 588 #endif // !defined(WSA_CMSG_DATA)
 589     CASecureEndpoint_t sep = {.endpoint = {.adapter = CA_ADAPTER_IP, .flags = flags}};
 590
 591     if (flags & CA_IPV6)
 592     {
 593         /** @todo figure out correct usage for ifindex, and sin6_scope_id.*/
 594         if ((flags & CA_MULTICAST) && pktinfo)
 595         {
 596             struct in6_addr *addr = &(((struct in6_pktinfo *)pktinfo)->ipi6_addr);
 597             unsigned char topbits = ((unsigned char *)addr)[0];
 598             if (topbits != 0xff)
 599             {
 600                 sep.endpoint.flags &= ~CA_MULTICAST;
 601             }
 602         }
 603     }
 604     else
 605     {
 606         if ((flags & CA_MULTICAST) && pktinfo)
 607         {
 608             struct in_addr *addr = &((struct in_pktinfo *)pktinfo)->ipi_addr;
 609             uint32_t host = ntohl(addr->s_addr);
 610             unsigned char topbits = ((unsigned char *)&host)[3];
 611             if (topbits < 224 || topbits > 239)
 612             {
 613                 sep.endpoint.flags &= ~CA_MULTICAST;
 614             }
 615         }
 616     }
 617
 618     CAConvertAddrToName(&srcAddr, namelen, sep.endpoint.addr, &sep.endpoint.port);
 619
 620     if (flags & CA_SECURE)
 621     {
 622 #ifdef __WITH_DTLS__
 623         int ret = CAAdapterNetDtlsDecrypt(&sep, (uint8_t *)recvBuffer, recvLen);
 624         OIC_LOG_V(DEBUG, TAG, "CAAdapterNetDtlsDecrypt returns [%d]", ret);
 625 #else
 626         OIC_LOG(ERROR, TAG, "Encrypted message but no DTLS");
 627 #endif
 628     }
 629     else
 630     {
 631         if (g_packetReceivedCallback)
 632         {
 633             g_packetReceivedCallback(&sep, recvBuffer, recvLen);
 634         }
 635     }
 636
 637     return CA_STATUS_OK;
 638
 639 }
 640
 641 void CAIPPullData()
 642 {
 643     OIC_LOG(DEBUG, TAG, "IN");
 644     OIC_LOG(DEBUG, TAG, "OUT");
 645 }
 646
 647 static int CACreateSocket(int family, uint16_t *port)
 648 {
 649     int socktype = SOCK_DGRAM;
 650 #ifdef SOCK_CLOEXEC
 651     socktype |= SOCK_CLOEXEC;
 652 #endif
 653     int fd = socket(family, socktype, IPPROTO_UDP);
 654     if (-1 == fd)
 655     {
 656         OIC_LOG_V(ERROR, TAG, "create socket failed: %s", CAIPS_GET_ERROR);
 657         return -1;
 658     }
 659
 660 #if !defined(SOCK_CLOEXEC) && defined(FD_CLOEXEC)
 661     int fl = fcntl(fd, F_GETFD);
 662     if (-1 == fl || -1 == fcntl(fd, F_SETFD, fl|FD_CLOEXEC))
 663     {
 664         OIC_LOG_V(ERROR, TAG, "set FD_CLOEXEC failed: %s", strerror(errno));
 665         close(fd);
 666         return -1;
 667     }
 668 #endif
 669     struct sockaddr_storage sa = { .ss_family = family };
 670     socklen_t socklen;
 671
 672     if (family == AF_INET6)
 673     {
 674         int on = 1;
 675
 676         if (-1 == setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof (on)))
 677         {
 678             OIC_LOG_V(ERROR, TAG, "IPV6_V6ONLY failed: %s", CAIPS_GET_ERROR);
 679         }
 680
 681         if (*port) // only do this for multicast ports
 682         {
 683 #if defined(IPV6_RECVPKTINFO)
 684             if (-1 == setsockopt(fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &on, sizeof (on)))
 685 #else
 686             if (-1 == setsockopt(fd, IPPROTO_IPV6, IPV6_PKTINFO, &on, sizeof (on)))
 687 #endif
 688             {
 689                 OIC_LOG_V(ERROR, TAG, "IPV6_RECVPKTINFO failed: %s",CAIPS_GET_ERROR);
 690             }
 691         }
 692
 693         ((struct sockaddr_in6 *)&sa)->sin6_port = htons(*port);
 694         socklen = sizeof (struct sockaddr_in6);
 695     }
 696     else
 697     {
 698         if (*port) // only do this for multicast ports
 699         {
 700             int on = 1;
 701             if (-1 == setsockopt(fd, IPPROTO_IP, IP_PKTINFO, &on, sizeof (on)))
 702             {
 703                 OIC_LOG_V(ERROR, TAG, "IP_PKTINFO failed: %s", CAIPS_GET_ERROR);
 704             }
 705         }
 706
 707         ((struct sockaddr_in *)&sa)->sin_port = htons(*port);
 708         socklen = sizeof (struct sockaddr_in);
 709     }
 710
 711     if (*port) // use the given port
 712     {
 713         int on = 1;
 714         if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof (on)))
 715         {
 716             OIC_LOG_V(ERROR, TAG, "SO_REUSEADDR failed: %s", CAIPS_GET_ERROR);
 717 #ifdef _WIN32
 718             closesocket(fd);
 719 #else
 720             close(fd);
 721 #endif
 722             return -1;
 723         }
 724     }
 725
 726     if (-1 == bind(fd, (struct sockaddr *)&sa, socklen))
 727     {
 728         OIC_LOG_V(ERROR, TAG, "bind socket failed: %s", CAIPS_GET_ERROR);
 729 #ifdef _WIN32
 730         closesocket(fd);
 731 #else
 732         close(fd);
 733 #endif
 734         return -1;
 735     }
 736
 737     if (!*port) // return the assigned port
 738     {
 739         if (-1 == getsockname(fd, (struct sockaddr *)&sa, &socklen))
 740         {
 741             OIC_LOG_V(ERROR, TAG, "getsockname failed: %s", CAIPS_GET_ERROR);
 742 #ifdef _WIN32
 743             closesocket(fd);
 744 #else
 745             close(fd);
 746 #endif
 747             return -1;
 748         }
 749         *port = ntohs(family == AF_INET6 ?
 750                       ((struct sockaddr_in6 *)&sa)->sin6_port :
 751                       ((struct sockaddr_in *)&sa)->sin_port);
 752     }
 753
 754     return fd;
 755 }
 756
 757 #define CHECKFD(FD) \
 758     if (FD > caglobals.ip.maxfd) \
 759         caglobals.ip.maxfd = FD;
 760 #define NEWSOCKET(FAMILY, NAME) \
 761     caglobals.ip.NAME.fd = CACreateSocket(FAMILY, &caglobals.ip.NAME.port); \
 762     CHECKFD(caglobals.ip.NAME.fd)
 763
 764 static void CAInitializeNetlink()
 765 {
 766     caglobals.ip.netlinkFd = -1;
 767 #ifdef __linux__
 768     // create NETLINK fd for interface change notifications
 769     struct sockaddr_nl sa = { AF_NETLINK, 0, 0, RTMGRP_LINK };
 770
 771     caglobals.ip.netlinkFd = socket(AF_NETLINK, SOCK_RAW|SOCK_CLOEXEC, NETLINK_ROUTE);
 772     if (caglobals.ip.netlinkFd == -1)
 773     {
 774         OIC_LOG_V(ERROR, TAG, "netlink socket failed: %s", strerror(errno));
 775     }
 776     else
 777     {
 778         int r = bind(caglobals.ip.netlinkFd, (struct sockaddr *)&sa, sizeof (sa));
 779         if (r)
 780         {
 781             OIC_LOG_V(ERROR, TAG, "netlink bind failed: %s", strerror(errno));
 782             close(caglobals.ip.netlinkFd);
 783             caglobals.ip.netlinkFd = -1;
 784         }
 785         else
 786         {
 787             CHECKFD(caglobals.ip.netlinkFd);
 788         }
 789     }
 790 #endif
 791 }
 792
 793 static void CAInitializeFastShutdownMechanism()
 794 {
 795     caglobals.ip.selectTimeout = -1; // don't poll for shutdown
 796     int ret = -1;
 797 #if defined(WSA_WAIT_EVENT_0)
 798     caglobals.ip.shutdownEvent = -1;
 799     caglobals.ip.shutdownEvent = WSACreateEvent();
 800
 801     if (caglobals.ip.shutdownEvent == WSA_INVALID_EVENT)
 802     {
 803         caglobals.ip.shutdownEvent = -1;
 804     }
 805     else
 806     {
 807         ret = 0;
 808     }
 809 #elif defined(HAVE_PIPE2)
 810     ret = pipe2(caglobals.ip.shutdownFds, O_CLOEXEC);
 811     CHECKFD(caglobals.ip.shutdownFds[0]);
 812     CHECKFD(caglobals.ip.shutdownFds[1]);
 813 #else
 814     ret = pipe(caglobals.ip.shutdownFds);
 815     if (-1 != ret)
 816     {
 817         ret = fcntl(caglobals.ip.shutdownFds[0], F_GETFD);
 818         if (-1 != ret)
 819         {
 820             ret = fcntl(caglobals.ip.shutdownFds[0], F_SETFD, ret|FD_CLOEXEC);
 821         }
 822         if (-1 != ret)
 823         {
 824             ret = fcntl(caglobals.ip.shutdownFds[1], F_GETFD);
 825         }
 826         if (-1 != ret)
 827         {
 828             ret = fcntl(caglobals.ip.shutdownFds[1], F_SETFD, ret|FD_CLOEXEC);
 829         }
 830         if (-1 == ret)
 831         {
 832             close(caglobals.ip.shutdownFds[1]);
 833             close(caglobals.ip.shutdownFds[0]);
 834             caglobals.ip.shutdownFds[0] = -1;
 835             caglobals.ip.shutdownFds[1] = -1;
 836         }
 837     }
 838     CHECKFD(caglobals.ip.shutdownFds[0]);
 839     CHECKFD(caglobals.ip.shutdownFds[1]);
 840 #endif
 841     if (-1 == ret)
 842     {
 843         OIC_LOG_V(ERROR, TAG, "fast shutdown mechanism init failed: %s", CAIPS_GET_ERROR);
 844         caglobals.ip.selectTimeout = SELECT_TIMEOUT; //poll needed for shutdown
 845     }
 846 }
 847
 848 CAResult_t CAIPStartServer(const ca_thread_pool_t threadPool)
 849 {
 850     CAResult_t res = CA_STATUS_OK;
 851
 852     if (caglobals.ip.started)
 853     {
 854         return res;
 855     }
 856 #if defined (_WIN32)
 857     WORD wVersionRequested = MAKEWORD(2, 2);
 858     WSADATA wsaData ={.wVersion = 0};
 859     int err = WSAStartup(wVersionRequested, &wsaData);
 860     if (err != 0)
 861     {
 862         OIC_LOG_V(ERROR, TAG, "WSAStartup failed: %i", err);
 863         return CA_STATUS_FAILED;
 864     }
 865     OIC_LOG(DEBUG, TAG, "WSAStartup Succeeded");
 866 #endif
 867     if (!IPv4MulticastAddress.s_addr)
 868     {
 869         (void)inet_pton(AF_INET, IPv4_MULTICAST, &IPv4MulticastAddress);
 870         (void)inet_pton(AF_INET6, IPv6_MULTICAST_INT, &IPv6MulticastAddressInt);
 871         (void)inet_pton(AF_INET6, IPv6_MULTICAST_LNK, &IPv6MulticastAddressLnk);
 872         (void)inet_pton(AF_INET6, IPv6_MULTICAST_RLM, &IPv6MulticastAddressRlm);
 873         (void)inet_pton(AF_INET6, IPv6_MULTICAST_ADM, &IPv6MulticastAddressAdm);
 874         (void)inet_pton(AF_INET6, IPv6_MULTICAST_SIT, &IPv6MulticastAddressSit);
 875         (void)inet_pton(AF_INET6, IPv6_MULTICAST_ORG, &IPv6MulticastAddressOrg);
 876         (void)inet_pton(AF_INET6, IPv6_MULTICAST_GLB, &IPv6MulticastAddressGlb);
 877     }
 878
 879     if (!caglobals.ip.ipv6enabled && !caglobals.ip.ipv4enabled)
 880     {
 881         caglobals.ip.ipv4enabled = true;  // only needed to run CA tests
 882     }
 883
 884     if (caglobals.ip.ipv6enabled)
 885     {
 886         NEWSOCKET(AF_INET6, u6)
 887         NEWSOCKET(AF_INET6, u6s)
 888         NEWSOCKET(AF_INET6, m6)
 889         NEWSOCKET(AF_INET6, m6s)
 890         OIC_LOG_V(INFO, TAG, "IPv6 unicast port: %u", caglobals.ip.u6.port);
 891     }
 892     if (caglobals.ip.ipv4enabled)
 893     {
 894         NEWSOCKET(AF_INET, u4)
 895         NEWSOCKET(AF_INET, u4s)
 896         NEWSOCKET(AF_INET, m4)
 897         NEWSOCKET(AF_INET, m4s)
 898         OIC_LOG_V(INFO, TAG, "IPv4 unicast port: %u", caglobals.ip.u4.port);
 899     }
 900
 901     OIC_LOG_V(DEBUG, TAG,
 902               "socket summary: u6=%d, u6s=%d, u4=%d, u4s=%d, m6=%d, m6s=%d, m4=%d, m4s=%d",
 903               caglobals.ip.u6.fd, caglobals.ip.u6s.fd, caglobals.ip.u4.fd, caglobals.ip.u4s.fd,
 904               caglobals.ip.m6.fd, caglobals.ip.m6s.fd, caglobals.ip.m4.fd, caglobals.ip.m4s.fd);
 905
 906     OIC_LOG_V(DEBUG, TAG,
 907               "port summary: u6 port=%d, u6s port=%d, u4 port=%d, u4s port=%d, m6 port=%d,"
 908               "m6s port=%d, m4 port=%d, m4s port=%d",
 909               caglobals.ip.u6.port, caglobals.ip.u6s.port, caglobals.ip.u4.port,
 910               caglobals.ip.u4s.port, caglobals.ip.m6.port, caglobals.ip.m6s.port,
 911               caglobals.ip.m4.port, caglobals.ip.m4s.port);
 912 #if defined (SIO_GET_EXTENSION_FUNCTION_POINTER)
 913     caglobals.ip.wsaRecvMsg = NULL;
 914     GUID GuidWSARecvMsg = WSAID_WSARECVMSG;
 915     DWORD copied = 0;
 916     err = WSAIoctl(caglobals.ip.u4.fd, SIO_GET_EXTENSION_FUNCTION_POINTER, &GuidWSARecvMsg, sizeof(GuidWSARecvMsg), &(caglobals.ip.wsaRecvMsg), sizeof(caglobals.ip.wsaRecvMsg), &copied, 0, 0);
 917     if (0 != err)
 918     {
 919         OIC_LOG_V(ERROR, TAG, "WSAIoctl failed %i", WSAGetLastError());
 920         return CA_STATUS_FAILED;
 921     }
 922 #endif
 923     // set up appropriate FD mechanism for fast shutdown
 924     CAInitializeFastShutdownMechanism();
 925
 926     // create source of network interface change notifications
 927     CAInitializeNetlink();
 928
 929     caglobals.ip.selectTimeout = CAGetPollingInterval(caglobals.ip.selectTimeout);
 930
 931     res = CAIPStartListenServer();
 932     if (CA_STATUS_OK != res)
 933     {
 934         OIC_LOG_V(ERROR, TAG, "Failed to start listening server![%d]", res);
 935         return res;
 936     }
 937
 938     caglobals.ip.terminate = false;
 939     res = ca_thread_pool_add_task(threadPool, CAReceiveHandler, NULL);
 940     if (CA_STATUS_OK != res)
 941     {
 942         OIC_LOG(ERROR, TAG, "thread_pool_add_task failed");
 943         return res;
 944     }
 945     OIC_LOG(DEBUG, TAG, "CAReceiveHandler thread started successfully.");
 946
 947     caglobals.ip.started = true;
 948     return CA_STATUS_OK;
 949 }
 950
 951 void CAIPStopServer()
 952 {
 953     caglobals.ip.started = false;
 954     caglobals.ip.terminate = true;
 955
 956 #if !defined(WSA_WAIT_EVENT_0)
 957     if (caglobals.ip.shutdownFds[1] != -1)
 958     {
 959         close(caglobals.ip.shutdownFds[1]);
 960         // receive thread will stop immediately
 961     }
 962     else
 963     {
 964         // receive thread will stop in SELECT_TIMEOUT seconds.
 965     }
 966 #else
 967     if (!WSASetEvent(caglobals.ip.shutdownEvent))
 968     {
 969         OIC_LOG_V(DEBUG, TAG, "set shutdown event failed: %#08X", GetLastError());
 970     }
 971 #endif
 972 }
 973
 974 void CAWakeUpForChange()
 975 {
 976 #if !defined(WSA_WAIT_EVENT_0)
 977     if (caglobals.ip.shutdownFds[1] != -1)
 978     {
 979         ssize_t len = 0;
 980         do
 981         {
 982             len = write(caglobals.ip.shutdownFds[1], "w", 1);
 983         } while ((len == -1) && (errno == EINTR));
 984         if ((len == -1) && (errno != EINTR) && (errno != EPIPE))
 985         {
 986             OIC_LOG_V(DEBUG, TAG, "write failed: %s", strerror(errno));
 987         }
 988     }
 989 #else
 990     if (!WSASetEvent(caglobals.ip.shutdownEvent))
 991     {
 992         OIC_LOG_V(DEBUG, TAG, "set shutdown event failed: %#08X", GetLastError());
 993     }
 994 #endif
 995 }
 996
 997 static void applyMulticastToInterface4(uint32_t ifindex)
 998 {
 999     if (!caglobals.ip.ipv4enabled)
1000     {
1001         return;
1002     }
1003
1004 #if defined(USE_IP_MREQN)
1005     struct ip_mreqn mreq = { .imr_multiaddr = IPv4MulticastAddress,
1006                              .imr_address.s_addr = htonl(INADDR_ANY),
1007                              .imr_ifindex = ifindex };
1008 #else
1009     struct ip_mreq mreq  = { .imr_multiaddr = IPv4MulticastAddress,
1010                              .imr_interface.s_addr = htonl(ifindex) };
1011 #endif
1012
1013     int ret = setsockopt(caglobals.ip.m4.fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof (mreq));
1014     if (-1 == ret)
1015     {
1016 #if !defined(WSAEINVAL)
1017         if (EADDRINUSE != errno)
1018 #else
1019         if (WSAEINVAL != WSAGetLastError()) // Joining multicast group more than once (IPv4 Flavor)
1020 #endif
1021         {
1022             OIC_LOG_V(ERROR, TAG, "       IPv4 IP_ADD_MEMBERSHIP failed: %s", CAIPS_GET_ERROR);
1023         }
1024     }
1025     ret = setsockopt(caglobals.ip.m4s.fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof (mreq));
1026     if (-1 == ret)
1027     {
1028 #if !defined(WSAEINVAL)
1029         if (EADDRINUSE != errno)
1030 #else
1031         if (WSAEINVAL != WSAGetLastError()) // Joining multicast group more than once (IPv4 Flavor)
1032 #endif
1033         {
1034             OIC_LOG_V(ERROR, TAG, "SECURE IPv4 IP_ADD_MEMBERSHIP failed: %s", CAIPS_GET_ERROR);
1035         }
1036     }
1037 }
1038
1039 static void applyMulticast6(int fd, struct in6_addr *addr, uint32_t ifindex)
1040 {
1041     struct ipv6_mreq mreq = {.ipv6mr_multiaddr = *addr,
1042                              .ipv6mr_interface = ifindex };
1043     int ret = setsockopt(fd, IPPROTO_IPV6, IPV6_JOIN_GROUP, &mreq, sizeof (mreq));
1044     if (-1 == ret)
1045     {
1046 #if !defined(_WIN32)
1047                 if (EADDRINUSE != errno)
1048 #else
1049                 if (WSAEINVAL != WSAGetLastError()) // Joining multicast group more than once (IPv6 Flavor)
1050 #endif
1051         {
1052             OIC_LOG_V(ERROR, TAG, "IPv6 IPV6_JOIN_GROUP failed: %s", CAIPS_GET_ERROR);
1053         }
1054     }
1055 }
1056
1057 static void applyMulticastToInterface6(uint32_t ifindex)
1058 {
1059     if (!caglobals.ip.ipv6enabled)
1060     {
1061         return;
1062     }
1063     //applyMulticast6(caglobals.ip.m6.fd, &IPv6MulticastAddressInt, ifindex);
1064     applyMulticast6(caglobals.ip.m6.fd, &IPv6MulticastAddressLnk, ifindex);
1065     //applyMulticast6(caglobals.ip.m6.fd, &IPv6MulticastAddressRlm, ifindex);
1066     //applyMulticast6(caglobals.ip.m6.fd, &IPv6MulticastAddressAdm, ifindex);
1067     //applyMulticast6(caglobals.ip.m6.fd, &IPv6MulticastAddressSit, ifindex);
1068     //applyMulticast6(caglobals.ip.m6.fd, &IPv6MulticastAddressOrg, ifindex);
1069     //applyMulticast6(caglobals.ip.m6.fd, &IPv6MulticastAddressGlb, ifindex);
1070
1071     //applyMulticast6(caglobals.ip.m6s.fd, &IPv6MulticastAddressInt, ifindex);
1072     applyMulticast6(caglobals.ip.m6s.fd, &IPv6MulticastAddressLnk, ifindex);
1073     //applyMulticast6(caglobals.ip.m6s.fd, &IPv6MulticastAddressRlm, ifindex);
1074     //applyMulticast6(caglobals.ip.m6s.fd, &IPv6MulticastAddressAdm, ifindex);
1075     //applyMulticast6(caglobals.ip.m6s.fd, &IPv6MulticastAddressSit, ifindex);
1076     //applyMulticast6(caglobals.ip.m6s.fd, &IPv6MulticastAddressOrg, ifindex);
1077     //applyMulticast6(caglobals.ip.m6s.fd, &IPv6MulticastAddressGlb, ifindex);
1078 }
1079
1080 CAResult_t CAIPStartListenServer()
1081 {
1082     u_arraylist_t *iflist = CAIPGetInterfaceInformation(0);
1083     if (!iflist)
1084     {
1085         OIC_LOG_V(ERROR, TAG, "CAIPGetInterfaceInformation() failed: %s", strerror(errno));
1086         return CA_STATUS_FAILED;
1087     }
1088
1089     uint32_t len = u_arraylist_length(iflist);
1090     OIC_LOG_V(DEBUG, TAG, "IP network interfaces found: %d", len);
1091
1092     for (uint32_t i = 0; i < len; i++)
1093     {
1094         CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
1095
1096         if (!ifitem)
1097         {
1098             continue;
1099         }
1100         if ((ifitem->flags & IFF_UP_RUNNING_FLAGS) != IFF_UP_RUNNING_FLAGS)
1101         {
1102             continue;
1103         }
1104         if (ifitem->family == AF_INET)
1105         {
1106             OIC_LOG_V(DEBUG, TAG, "Adding IPv4 interface %i to multicast group", ifitem->index);
1107             applyMulticastToInterface4(ifitem->index);
1108         }
1109         if (ifitem->family == AF_INET6)
1110         {
1111             OIC_LOG_V(DEBUG, TAG, "Adding IPv6 interface %i to multicast group", ifitem->index);
1112             applyMulticastToInterface6(ifitem->index);
1113         }
1114     }
1115
1116     u_arraylist_destroy(iflist);
1117     return CA_STATUS_OK;
1118 }
1119
1120 CAResult_t CAIPStopListenServer()
1121 {
1122     u_arraylist_t *iflist = CAIPGetInterfaceInformation(0);
1123     if (!iflist)
1124     {
1125         OIC_LOG_V(ERROR, TAG, "Get interface info failed: %s", strerror(errno));
1126         return CA_STATUS_FAILED;
1127     }
1128
1129     uint32_t len = u_arraylist_length(iflist);
1130     OIC_LOG_V(DEBUG, TAG, "IP network interfaces found: %d", len);
1131
1132     for (uint32_t i = 0; i < len; i++)
1133     {
1134         CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
1135
1136         if (!ifitem)
1137         {
1138             continue;
1139         }
1140         if ((ifitem->flags & IFF_UP_RUNNING_FLAGS) != IFF_UP_RUNNING_FLAGS)
1141         {
1142             continue;
1143         }
1144         if (ifitem->family == AF_INET)
1145         {
1146             CLOSE_SOCKET(m4);
1147             CLOSE_SOCKET(m4s);
1148             OIC_LOG_V(DEBUG, TAG, "IPv4 network interface: %s cloed", ifitem->name);
1149         }
1150         if (ifitem->family == AF_INET6)
1151         {
1152             CLOSE_SOCKET(m6);
1153             CLOSE_SOCKET(m6s);
1154             OIC_LOG_V(DEBUG, TAG, "IPv6 network interface: %s", ifitem->name);
1155         }
1156     }
1157     u_arraylist_destroy(iflist);
1158     return CA_STATUS_OK;
1159 }
1160
1161 static void CAProcessNewInterface(CAInterface_t *ifitem)
1162 {
1163     if (!ifitem)
1164     {
1165         OIC_LOG(DEBUG, TAG, "ifitem is null");
1166         return;
1167     }
1168
1169     if (ifitem->family == AF_INET6)
1170     {
1171         applyMulticastToInterface6(ifitem->index);
1172     }
1173     if (ifitem->family == AF_INET)
1174     {
1175         applyMulticastToInterface4(ifitem->index);
1176     }
1177 }
1178
1179 void CAIPSetPacketReceiveCallback(CAIPPacketReceivedCallback callback)
1180 {
1181     g_packetReceivedCallback = callback;
1182 }
1183
1184 void CAIPSetExceptionCallback(CAIPExceptionCallback callback)
1185 {
1186     g_exceptionCallback = callback;
1187 }
1188
1189 void CAIPSetConnectionStateChangeCallback(CAIPConnectionStateChangeCallback callback)
1190 {
1191     CAIPSetNetworkMonitorCallback(callback);
1192 }
1193
1194 static void sendData(int fd, const CAEndpoint_t *endpoint,
1195                      const void *data, uint32_t dlen,
1196                      const char *cast, const char *fam)
1197 {
1198     OIC_LOG(DEBUG, TAG, "IN");
1199
1200     if (!endpoint)
1201     {
1202         OIC_LOG(DEBUG, TAG, "endpoint is null");
1203         return;
1204     }
1205
1206     char *secure = (endpoint->flags & CA_SECURE) ? "secure " : "";
1207
1208     (void)secure;   // eliminates release warning
1209     (void)cast;
1210     (void)fam;
1211
1212     struct sockaddr_storage sock;
1213     CAConvertNameToAddr(endpoint->addr, endpoint->port, &sock);
1214
1215     socklen_t socklen;
1216     if (sock.ss_family == AF_INET6)
1217     {
1218         /** @todo figure out correct usage for ifindex, and sin6_scope_id */
1219         socklen = sizeof(struct sockaddr_in6);
1220     }
1221     else
1222     {
1223         socklen = sizeof(struct sockaddr_in);
1224     }
1225 #if !defined(_WIN32)
1226     ssize_t len = sendto(fd, data, dlen, 0, (struct sockaddr *)&sock, socklen);
1227     if (-1 == len)
1228     {
1229         OIC_LOG_V(ERROR, TAG, "%s%s %s sendTo failed: %s", secure, cast, fam, strerror(errno));
1230     }
1231     else
1232     {
1233         OIC_LOG_V(INFO, TAG, "%s%s %s sendTo is successful: %zd bytes", secure, cast, fam, len);
1234     }
1235 #else
1236     int err = 0;
1237     int len = 0;
1238     int sent = 0;
1239     do {
1240         len = sendto(fd, ((char*)data) + sent, dlen - sent, 0, (struct sockaddr *)&sock, socklen);
1241         if (SOCKET_ERROR == len)
1242         {
1243             err = WSAGetLastError();
1244             if ((WSAEWOULDBLOCK != err) && (WSAENOBUFS != err))
1245             {
1246                 OIC_LOG_V(ERROR, TAG, "%s%s %s sendTo failed: %i", secure, cast, fam, err);
1247             }
1248         }
1249         else
1250         {
1251             sent += len;
1252             if (sent != len)
1253             {
1254                 OIC_LOG_V(DEBUG, TAG, "%s%s %s sendTo (Partial Send) is successful: "
1255                                       "currently sent: %ld bytes, "
1256                                       "total sent: %ld bytes, "
1257                                       "remaining: %ld bytes",
1258                                       secure, cast, fam, len, sent, dlen-sent);
1259             }
1260             else
1261             {
1262                 OIC_LOG_V(INFO, TAG, "%s%s %s sendTo is successful: %ld bytes",
1263                                      secure, cast, fam, len);
1264             }
1265         }
1266     } while ((SOCKET_ERROR == len) && ((WSAEWOULDBLOCK == err) || (WSAENOBUFS == err)) || (sent < dlen));
1267 #endif
1268 }
1269
1270 static void sendMulticastData6(const u_arraylist_t *iflist,
1271                                CAEndpoint_t *endpoint,
1272                                const void *data, uint32_t datalen)
1273 {
1274     if (!endpoint)
1275     {
1276         OIC_LOG(DEBUG, TAG, "endpoint is null");
1277         return;
1278     }
1279
1280     int scope = endpoint->flags & CA_SCOPE_MASK;
1281     char *ipv6mcname = ipv6mcnames[scope];
1282     if (!ipv6mcname)
1283     {
1284         OIC_LOG_V(INFO, TAG, "IPv6 multicast scope invalid: %d", scope);
1285         return;
1286     }
1287     OICStrcpy(endpoint->addr, sizeof(endpoint->addr), ipv6mcname);
1288     int fd = caglobals.ip.u6.fd;
1289
1290     uint32_t len = u_arraylist_length(iflist);
1291     for (uint32_t i = 0; i < len; i++)
1292     {
1293         CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
1294         if (!ifitem)
1295         {
1296             continue;
1297         }
1298         if ((ifitem->flags & IFF_UP_RUNNING_FLAGS) != IFF_UP_RUNNING_FLAGS)
1299         {
1300             continue;
1301         }
1302         if (ifitem->family != AF_INET6)
1303         {
1304             continue;
1305         }
1306
1307         int index = ifitem->index;
1308         if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_IF, &index, sizeof (index)))
1309         {
1310             OIC_LOG_V(ERROR, TAG, "setsockopt6 failed: %s", CAIPS_GET_ERROR);
1311             return;
1312         }
1313         sendData(fd, endpoint, data, datalen, "multicast", "ipv6");
1314     }
1315 }
1316
1317 static void sendMulticastData4(const u_arraylist_t *iflist,
1318                                CAEndpoint_t *endpoint,
1319                                const void *data, uint32_t datalen)
1320 {
1321     VERIFY_NON_NULL_VOID(endpoint, TAG, "endpoint is NULL");
1322
1323 #if defined(USE_IP_MREQN)
1324     struct ip_mreqn mreq = { .imr_multiaddr = IPv4MulticastAddress,
1325                              .imr_address.s_addr = htonl(INADDR_ANY),
1326                              .imr_ifindex = 0};
1327 #else
1328     struct ip_mreq mreq  = { .imr_multiaddr = IPv4MulticastAddress,
1329                              .imr_interface = {0}};
1330 #endif
1331
1332     OICStrcpy(endpoint->addr, sizeof(endpoint->addr), IPv4_MULTICAST);
1333     int fd = caglobals.ip.u4.fd;
1334
1335     uint32_t len = u_arraylist_length(iflist);
1336     for (uint32_t i = 0; i < len; i++)
1337     {
1338         CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
1339         if (!ifitem)
1340         {
1341             continue;
1342         }
1343         if ((ifitem->flags & IFF_UP_RUNNING_FLAGS) != IFF_UP_RUNNING_FLAGS)
1344         {
1345             continue;
1346         }
1347         if (ifitem->family != AF_INET)
1348         {
1349             continue;
1350         }
1351 #if defined(USE_IP_MREQN)
1352         mreq.imr_ifindex = ifitem->index;
1353 #else
1354         mreq.imr_interface.s_addr = htonl(ifitem->index);
1355 #endif
1356         if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, &mreq, sizeof (mreq)))
1357         {
1358             OIC_LOG_V(ERROR, TAG, "send IP_MULTICAST_IF failed: %s (using defualt)",
1359                     CAIPS_GET_ERROR);
1360         }
1361         sendData(fd, endpoint, data, datalen, "multicast", "ipv4");
1362     }
1363 }
1364
1365 void CAIPSendData(CAEndpoint_t *endpoint, const void *data, uint32_t datalen,
1366                   bool isMulticast)
1367 {
1368     VERIFY_NON_NULL_VOID(endpoint, TAG, "endpoint is NULL");
1369     VERIFY_NON_NULL_VOID(data, TAG, "data is NULL");
1370
1371     bool isSecure = (endpoint->flags & CA_SECURE) != 0;
1372
1373     if (isMulticast)
1374     {
1375         endpoint->port = isSecure ? CA_SECURE_COAP : CA_COAP;
1376
1377         u_arraylist_t *iflist = CAIPGetInterfaceInformation(0);
1378         if (!iflist)
1379         {
1380             OIC_LOG_V(ERROR, TAG, "get interface info failed: %s", strerror(errno));
1381             return;
1382         }
1383
1384         if ((endpoint->flags & CA_IPV6) && caglobals.ip.ipv6enabled)
1385         {
1386             sendMulticastData6(iflist, endpoint, data, datalen);
1387         }
1388         if ((endpoint->flags & CA_IPV4) && caglobals.ip.ipv4enabled)
1389         {
1390             sendMulticastData4(iflist, endpoint, data, datalen);
1391         }
1392
1393         u_arraylist_destroy(iflist);
1394     }
1395     else
1396     {
1397         if (!endpoint->port)    // unicast discovery
1398         {
1399             endpoint->port = isSecure ? CA_SECURE_COAP : CA_COAP;
1400         }
1401
1402         int fd;
1403         if (caglobals.ip.ipv6enabled && (endpoint->flags & CA_IPV6))
1404         {
1405             fd = isSecure ? caglobals.ip.u6s.fd : caglobals.ip.u6.fd;
1406 #ifndef __WITH_DTLS__
1407             fd = caglobals.ip.u6.fd;
1408 #endif
1409             sendData(fd, endpoint, data, datalen, "unicast", "ipv6");
1410         }
1411         if (caglobals.ip.ipv4enabled && (endpoint->flags & CA_IPV4))
1412         {
1413             fd = isSecure ? caglobals.ip.u4s.fd : caglobals.ip.u4.fd;
1414 #ifndef __WITH_DTLS__
1415             fd = caglobals.ip.u4.fd;
1416 #endif
1417             sendData(fd, endpoint, data, datalen, "unicast", "ipv4");
1418         }
1419     }
1420 }
1421
1422 CAResult_t CAGetIPInterfaceInformation(CAEndpoint_t **info, uint32_t *size)
1423 {
1424     VERIFY_NON_NULL(info, TAG, "info is NULL");
1425     VERIFY_NON_NULL(size, TAG, "size is NULL");
1426
1427     u_arraylist_t *iflist = CAIPGetInterfaceInformation(0);
1428     if (!iflist)
1429     {
1430         OIC_LOG_V(ERROR, TAG, "get interface info failed: %s", strerror(errno));
1431         return CA_STATUS_FAILED;
1432     }
1433
1434     uint32_t len = u_arraylist_length(iflist);
1435     uint32_t length = len;
1436
1437 #ifdef __WITH_DTLS__
1438     //If DTLS is supported, each interface can support secure port as well
1439     length = len * 2;
1440 #endif
1441
1442     CAEndpoint_t *eps = (CAEndpoint_t *)OICCalloc(length, sizeof (CAEndpoint_t));
1443     if (!eps)
1444     {
1445         OIC_LOG(ERROR, TAG, "Malloc Failed");
1446         u_arraylist_destroy(iflist);
1447         return CA_MEMORY_ALLOC_FAILED;
1448     }
1449
1450     for (uint32_t i = 0, j = 0; i < len; i++)
1451     {
1452         CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
1453         if(!ifitem)
1454         {
1455             continue;
1456         }
1457
1458         eps[j].adapter = CA_ADAPTER_IP;
1459         eps[j].ifindex = 0;
1460
1461         if (ifitem->family == AF_INET6)
1462         {
1463             eps[j].flags = CA_IPV6;
1464             eps[j].port = caglobals.ip.u6.port;
1465         }
1466         else
1467         {
1468             eps[j].flags = CA_IPV4;
1469             eps[j].port = caglobals.ip.u4.port;
1470             /** @todo eps[j].addr not populated with IPv4 address string.
1471              * it was using ifitem->ipv4addr to accomplish this.
1472              * Need to understand what ipv4addr means to whom*/
1473         }
1474
1475 #ifdef __WITH_DTLS__
1476         j++;
1477
1478         eps[j].adapter = CA_ADAPTER_IP;
1479         eps[j].ifindex = 0;
1480
1481         if (ifitem->family == AF_INET6)
1482         {
1483             eps[j].flags = CA_IPV6 | CA_SECURE;
1484             eps[j].port = caglobals.ip.u6s.port;
1485         }
1486         else
1487         {
1488             eps[j].flags = CA_IPV4 | CA_SECURE;
1489             eps[j].port = caglobals.ip.u4s.port;
1490             inet_ntop(AF_INET, &(ifitem->ipv4addr), eps[j].addr, MAX_ADDR_STR_SIZE_CA);
1491         }
1492 #endif
1493         j++;
1494     }
1495
1496     *info = eps;
1497     *size = len;
1498
1499     u_arraylist_destroy(iflist);
1500
1501     return CA_STATUS_OK;
1502 }