Line data Source code
1 : /*
2 : *
3 : * Copyright (c) 2020 Project CHIP Authors
4 : * All rights reserved.
5 : *
6 : * Licensed under the Apache License, Version 2.0 (the "License");
7 : * you may not use this file except in compliance with the License.
8 : * You may obtain a copy of the License at
9 : *
10 : * http://www.apache.org/licenses/LICENSE-2.0
11 : *
12 : * Unless required by applicable law or agreed to in writing, software
13 : * distributed under the License is distributed on an "AS IS" BASIS,
14 : * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 : * See the License for the specific language governing permissions and
16 : * limitations under the License.
17 : */
18 :
19 : /**
20 : * @file
21 : * This file defines the CHIP Connection object that maintains a UDP connection.
22 : * It binds to any available local addr and port and begins listening.
23 : *
24 : */
25 :
26 : #pragma once
27 :
28 : #include <utility>
29 :
30 : #include <inet/IPAddress.h>
31 : #include <inet/IPPacketInfo.h>
32 : #include <inet/InetInterface.h>
33 : #include <inet/UDPEndPoint.h>
34 : #include <lib/core/CHIPCore.h>
35 : #include <transport/raw/Base.h>
36 :
37 : #if CHIP_SYSTEM_CONFIG_USE_OPEN_THREAD_ENDPOINT
38 : struct otInstance;
39 : #endif // CHIP_SYSTEM_CONFIG_USE_OPEN_THREAD_ENDPOINT
40 :
41 : namespace chip {
42 : namespace Transport {
43 :
44 : /** Defines listening parameters for setting up a UDP transport */
45 : class UdpListenParameters
46 : {
47 : public:
48 2 : explicit UdpListenParameters(Inet::EndPointManager<Inet::UDPEndPoint> * endPointManager) : mEndPointManager(endPointManager) {}
49 : UdpListenParameters(const UdpListenParameters &) = default;
50 : UdpListenParameters(UdpListenParameters &&) = default;
51 :
52 7 : Inet::EndPointManager<Inet::UDPEndPoint> * GetEndPointManager() { return mEndPointManager; }
53 :
54 14 : Inet::IPAddressType GetAddressType() const { return mAddressType; }
55 2 : UdpListenParameters & SetAddressType(Inet::IPAddressType type)
56 : {
57 2 : mAddressType = type;
58 :
59 2 : return *this;
60 : }
61 :
62 14 : uint16_t GetListenPort() const { return mListenPort; }
63 2 : UdpListenParameters & SetListenPort(uint16_t port)
64 : {
65 2 : mListenPort = port;
66 :
67 2 : return *this;
68 : }
69 :
70 7 : Inet::InterfaceId GetInterfaceId() const { return mInterfaceId; }
71 : UdpListenParameters & SetInterfaceId(Inet::InterfaceId id)
72 : {
73 : mInterfaceId = id;
74 :
75 : return *this;
76 : }
77 :
78 : /**
79 : * Networking Stack Native parameter (optional)
80 : */
81 7 : void * GetNativeParams() const { return mNativeParams; }
82 1 : UdpListenParameters & SetNativeParams(void * params)
83 : {
84 1 : mNativeParams = params;
85 :
86 1 : return *this;
87 : }
88 :
89 : private:
90 : Inet::EndPointManager<Inet::UDPEndPoint> * mEndPointManager; ///< Associated endpoint factory
91 : Inet::IPAddressType mAddressType = Inet::IPAddressType::kIPv6; ///< type of listening socket
92 : uint16_t mListenPort = CHIP_PORT; ///< UDP listen port
93 : Inet::InterfaceId mInterfaceId = Inet::InterfaceId::Null(); ///< Interface to listen on
94 : void * mNativeParams = nullptr;
95 : };
96 :
97 : /** Implements a transport using UDP. */
98 : class DLL_EXPORT UDP : public Base
99 : {
100 : /**
101 : * The State of the UDP connection
102 : *
103 : */
104 : enum class State
105 : {
106 : kNotReady = 0, /**< State before initialization. */
107 : kInitialized = 1, /**< State after class is listening and ready. */
108 : };
109 :
110 : public:
111 : ~UDP() override;
112 :
113 : /**
114 : * Initialize a UDP transport on a given port.
115 : *
116 : * @param params UDP configuration parameters for this transport
117 : *
118 : * @details
119 : * Generally send and receive ports should be the same and equal to CHIP_PORT.
120 : * The class allows separate definitions to allow local execution of several
121 : * Nodes.
122 : */
123 : CHIP_ERROR Init(UdpListenParameters & params);
124 :
125 : uint16_t GetBoundPort();
126 :
127 : /**
128 : * Close the open endpoint without destroying the object
129 : */
130 : void Close() override;
131 :
132 : CHIP_ERROR SendMessage(const Transport::PeerAddress & address, System::PacketBufferHandle && msgBuf) override;
133 :
134 : CHIP_ERROR MulticastGroupJoinLeave(const Transport::PeerAddress & address, bool join) override;
135 :
136 0 : bool CanListenMulticast() override
137 : {
138 0 : return (mState == State::kInitialized) && (mUDPEndpointType == Inet::IPAddressType::kIPv6);
139 : }
140 :
141 2 : bool CanSendToPeer(const Transport::PeerAddress & address) override
142 : {
143 4 : return (mState == State::kInitialized) && (address.GetTransportType() == Type::kUdp) &&
144 4 : (address.GetIPAddress().Type() == mUDPEndpointType);
145 : }
146 :
147 : private:
148 : // UDP message receive handler.
149 : static void OnUdpReceive(Inet::UDPEndPoint * endPoint, System::PacketBufferHandle && buffer,
150 : const Inet::IPPacketInfo * pktInfo);
151 :
152 : static void OnUdpError(Inet::UDPEndPoint * endPoint, CHIP_ERROR err, const Inet::IPPacketInfo * pktInfo);
153 :
154 : Inet::UDPEndPoint * mUDPEndPoint = nullptr; ///< UDP socket used by the transport
155 : Inet::IPAddressType mUDPEndpointType = Inet::IPAddressType::kUnknown; ///< Socket listening type
156 : State mState = State::kNotReady; ///< State of the UDP transport
157 : };
158 :
159 : } // namespace Transport
160 : } // namespace chip
|
