Line data    Source code

       1             : /*
       2             :  *
       3             :  *    Copyright (c) 2020 Project CHIP Authors
       4             :  *    Copyright (c) 2013-2017 Nest Labs, Inc.
       5             :  *    All rights reserved.
       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             :  *    @file
      22             :  *      This file implements the CHIP Connection object that maintains a UDP connection.
      23             :  */
      24             : #include <transport/raw/UDP.h>
      25             : 
      26             : #include <lib/support/CHIPFaultInjection.h>
      27             : #include <lib/support/CodeUtils.h>
      28             : #include <lib/support/logging/CHIPLogging.h>
      29             : #include <transport/raw/MessageHeader.h>
      30             : 
      31             : #include <inttypes.h>
      32             : 
      33             : namespace chip {
      34             : namespace Transport {
      35             : 
      36           7 : UDP::~UDP()
      37             : {
      38           7 :     Close();
      39           7 : }
      40             : 
      41           7 : CHIP_ERROR UDP::Init(UdpListenParameters & params)
      42             : {
      43           7 :     CHIP_ERROR err = CHIP_NO_ERROR;
      44             : 
      45           7 :     if (mState != State::kNotReady)
      46             :     {
      47           0 :         Close();
      48             :     }
      49             : 
      50           7 :     err = params.GetEndPointManager()->NewEndPoint(&mUDPEndPoint);
      51           7 :     SuccessOrExit(err);
      52             : 
      53           7 :     mUDPEndPoint->SetNativeParams(params.GetNativeParams());
      54             : 
      55           7 :     ChipLogDetail(Inet, "UDP::Init bind&listen port=%d", params.GetListenPort());
      56             : 
      57           7 :     err = mUDPEndPoint->Bind(params.GetAddressType(), Inet::IPAddress::Any, params.GetListenPort(), params.GetInterfaceId());
      58           7 :     SuccessOrExit(err);
      59             : 
      60           7 :     err = mUDPEndPoint->Listen(OnUdpReceive, OnUdpError, this);
      61           7 :     SuccessOrExit(err);
      62             : 
      63           7 :     mUDPEndpointType = params.GetAddressType();
      64             : 
      65           7 :     mState = State::kInitialized;
      66             : 
      67           7 :     ChipLogDetail(Inet, "UDP::Init bound to port=%d", mUDPEndPoint->GetBoundPort());
      68             : 
      69           0 : exit:
      70           7 :     if (err != CHIP_NO_ERROR)
      71             :     {
      72           0 :         ChipLogProgress(Inet, "Failed to initialize Udp transport: %" CHIP_ERROR_FORMAT, err.Format());
      73           0 :         if (mUDPEndPoint)
      74             :         {
      75           0 :             mUDPEndPoint->Free();
      76           0 :             mUDPEndPoint = nullptr;
      77             :         }
      78             :     }
      79             : 
      80           7 :     return err;
      81             : }
      82             : 
      83           3 : uint16_t UDP::GetBoundPort()
      84             : {
      85           3 :     VerifyOrDie(mUDPEndPoint != nullptr);
      86           3 :     return mUDPEndPoint->GetBoundPort();
      87             : }
      88             : 
      89          10 : void UDP::Close()
      90             : {
      91          10 :     if (mUDPEndPoint)
      92             :     {
      93             :         // Udp endpoint is only non null if udp endpoint is initialized and listening
      94           7 :         mUDPEndPoint->Close();
      95           7 :         mUDPEndPoint->Free();
      96           7 :         mUDPEndPoint = nullptr;
      97             :     }
      98          10 :     mState = State::kNotReady;
      99          10 : }
     100             : 
     101           4 : CHIP_ERROR UDP::SendMessage(const Transport::PeerAddress & address, System::PacketBufferHandle && msgBuf)
     102             : {
     103           4 :     VerifyOrReturnError(address.GetTransportType() == Type::kUdp, CHIP_ERROR_INVALID_ARGUMENT);
     104           4 :     VerifyOrReturnError(mState == State::kInitialized, CHIP_ERROR_INCORRECT_STATE);
     105           4 :     VerifyOrReturnError(mUDPEndPoint != nullptr, CHIP_ERROR_INCORRECT_STATE);
     106             : 
     107           4 :     Inet::IPPacketInfo addrInfo;
     108           4 :     addrInfo.Clear();
     109             : 
     110           4 :     addrInfo.DestAddress = address.GetIPAddress();
     111           4 :     addrInfo.DestPort    = address.GetPort();
     112           4 :     addrInfo.Interface   = address.GetInterface();
     113             : 
     114             :     // Drop the message and return. Free the buffer.
     115           4 :     CHIP_FAULT_INJECT(FaultInjection::kFault_DropOutgoingUDPMsg, msgBuf = nullptr; return CHIP_ERROR_CONNECTION_ABORTED;);
     116             : 
     117           3 :     return mUDPEndPoint->SendMsg(&addrInfo, std::move(msgBuf));
     118             : }
     119             : 
     120           2 : void UDP::OnUdpReceive(Inet::UDPEndPoint * endPoint, System::PacketBufferHandle && buffer, const Inet::IPPacketInfo * pktInfo)
     121             : {
     122           2 :     CHIP_ERROR err          = CHIP_NO_ERROR;
     123           2 :     UDP * udp               = reinterpret_cast<UDP *>(endPoint->mAppState);
     124           2 :     PeerAddress peerAddress = PeerAddress::UDP(pktInfo->SrcAddress, pktInfo->SrcPort, pktInfo->Interface);
     125             : 
     126           2 :     CHIP_FAULT_INJECT(FaultInjection::kFault_DropIncomingUDPMsg, buffer = nullptr; return;);
     127             : 
     128           2 :     udp->HandleMessageReceived(peerAddress, std::move(buffer));
     129             : 
     130           2 :     if (err != CHIP_NO_ERROR)
     131             :     {
     132           0 :         ChipLogError(Inet, "Failed to receive UDP message: %" CHIP_ERROR_FORMAT, err.Format());
     133             :     }
     134             : }
     135             : 
     136           0 : void UDP::OnUdpError(Inet::UDPEndPoint * endPoint, CHIP_ERROR err, const Inet::IPPacketInfo * pktInfo)
     137             : {
     138           0 :     ChipLogError(Inet, "Failed to receive UDP message: %" CHIP_ERROR_FORMAT, err.Format());
     139           0 : }
     140             : 
     141           0 : CHIP_ERROR UDP::MulticastGroupJoinLeave(const Transport::PeerAddress & address, bool join)
     142             : {
     143             :     char addressStr[Transport::PeerAddress::kMaxToStringSize];
     144           0 :     address.ToString(addressStr, Transport::PeerAddress::kMaxToStringSize);
     145             : 
     146           0 :     if (join)
     147             :     {
     148           0 :         ChipLogProgress(Inet, "Joining Multicast Group with address %s", addressStr);
     149           0 :         return mUDPEndPoint->JoinMulticastGroup(mUDPEndPoint->GetBoundInterface(), address.GetIPAddress());
     150             :     }
     151             : 
     152           0 :     ChipLogProgress(Inet, "Leaving Multicast Group with address %s", addressStr);
     153           0 :     return mUDPEndPoint->LeaveMulticastGroup(mUDPEndPoint->GetBoundInterface(), address.GetIPAddress());
     154             : }
     155             : 
     156             : } // namespace Transport
     157             : } // namespace chip