1 /*
2  * Copyright (C) 2021-2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifndef OBEX_SOCKET_TRANSPORT_H
17 #define OBEX_SOCKET_TRANSPORT_H
18 
19 #include <atomic>
20 #include <cstdint>
21 #include <unordered_map>
22 #include "dispatcher.h"
23 #include "obex_packet.h"
24 #include "obex_transport.h"
25 #include "obex_types.h"
26 #include "transport/transport.h"
27 
28 namespace OHOS {
29 namespace bluetooth {
30 class ObexSocketTransport : public ObexTransport {
31 public:
32     ObexSocketTransport(
33         DataTransport *dataTransport, uint16_t sendMtu, uint16_t recvMtu, const std::string &parentTranKey);
34     virtual ~ObexSocketTransport();
35     bool Write(Packet &pkt) override;
36     // the maximum allowed OBEX packet that can be send over the transport
37     int GetMaxSendPacketSize() override;
38     // the maximum allowed OBEX packet that can be received over the transport
39     int GetMaxReceivePacketSize() override;
40     // This function is used to get the Bluetooth address of the peer of the connected channel
41     virtual const RawAddress &GetRemoteAddress() override;
42     // is transport Connected
43     virtual bool IsConnected() override;
44     // get transport key
45     const std::string &GetTransportKey() override;
46 
47 private:
48     std::unique_ptr<DataTransport> dataTransport_ = nullptr;
49     bool isConnected_ = false;
50     std::string tranKey_ = "";
51     uint16_t sendMtu_ = 0;
52     uint16_t recvMtu_ = 0;
53     RawAddress remoteBtAddr_ {""};
54     BT_DISALLOW_COPY_AND_ASSIGN(ObexSocketTransport);
55 };
56 
57 class ObexClientSocketTransport : public ObexClientTransport {
58 public:
59     struct Option {
60         BtAddr addr_ {};
61         bool isGoepL2capPSM_ = false;
62         uint16_t lpsm_ = 0;
63         uint16_t scn_ = 0;
64         uint16_t mtu_ = 0;
65     };
66     ObexClientSocketTransport(const Option &option, ObexTransportObserver &observer, utility::Dispatcher &dispatcher);
67     virtual ~ObexClientSocketTransport();
68     int Connect() override;
69     int Disconnect() override;
70     bool Write(Packet &pkt) override;
71     // the maximum allowed OBEX packet that can be send over the transport
72     int GetMaxSendPacketSize() override;
73     // the maximum allowed OBEX packet that can be received over the transport
74     int GetMaxReceivePacketSize() override;
75     // This function is used to get the Bluetooth address of the peer of the connected channel
76     const RawAddress &GetRemoteAddress() override;
77     // is transport Connected
78     bool IsConnected() override;
79     // get transport key
80     const std::string &GetTransportKey() override;
81 
82 private:
83     const RawAddress &PrivateGetRemoteAddress();
84     static const uint8_t TRANSPORT_KEY_NUM_LEN = 4;
85     class TransportObserver : public DataTransportObserver {
86     public:
87         explicit TransportObserver(ObexClientSocketTransport &obexTran);
88         virtual ~TransportObserver() = default;
89         // The event is triggered when server accept a new connection.
OnConnectIncoming(const RawAddress & addr,uint16_t port)90         void OnConnectIncoming(const RawAddress &addr, uint16_t port) override {};
91         // The event is triggered when server accept a new connection.
OnIncomingDisconnected(const RawAddress & addr)92         void OnIncomingDisconnected(const RawAddress &addr) override {};
93         // The event is triggered when connection complete successfully.
94         void OnConnected(DataTransport *transport, uint16_t sendMTU, uint16_t recvMTU) override;
95         // The event is triggered when a disconnect request is received.
96         void OnDisconnected(DataTransport *transport) override;
97         // The event is triggered when the disconnection process is successful.
98         void OnDisconnectSuccess(DataTransport *transport) override;
99         // The event is triggered when data is received from stack.
100         void OnDataAvailable(DataTransport *transport, Packet *pkt) override;
101         void OnDataAvailable(DataTransport *transport) override;
102         // The event is triggered when peer or RFCOMM/L2CAP is not available to receive data.
103         void OnDataBusy(DataTransport *transport, uint8_t isBusy) override;
104         // The event is triggered when process is failed.
105         void OnTransportError(DataTransport *transport, int errType) override;
106 
107     private:
108         ObexClientSocketTransport &obexTran_;
109         // The event is triggered when connection complete successfully.
110         void ProcessOnConnected(DataTransport *transport, uint16_t sendMTU, uint16_t recvMTU);
111         // The event is triggered when a disconnect request is received.
112         void ProcessOnDisconnected();
113         // The event is triggered when the disconnection process is successful.
114         void ProcessOnDisconnectSuccess();
115         // The event is triggered when data is received from stack.
116         void ProcessOnDataAvailable(DataTransport *transport, Packet *pkt);
117         // The event is triggered when peer or RFCOMM/L2CAP is not available to receive data.
118         void ProcessOnDataBusy(uint8_t isBusy);
119         // The event is triggered when process is failed.
120         void ProcessOnTransportError(int errType);
121         BT_DISALLOW_COPY_AND_ASSIGN(TransportObserver);
122     };
123     std::string MakeTransportKey(bool isGoepL2capPSM, uint16_t scn);
124     std::unique_ptr<TransportObserver> transportObserver_ = nullptr;
125     std::unique_ptr<DataTransport> dataTransport_ = nullptr;
126     bool isConnected_ = false;
127     std::string tranKey_ = "";
128     uint16_t sendMtu_ = 0;
129     uint16_t recvMtu_ = 0;
130     utility::Dispatcher &dispatcher_;
131     RawAddress remoteBtAddr_ {""};
132     BT_DISALLOW_COPY_AND_ASSIGN(ObexClientSocketTransport);
133 };
134 class ObexServerSocketTransport : public ObexServerTransport {
135 public:
136     struct Option {
137         bool isGoepL2capPSM_ = false;
138         uint16_t scn_ = 0;
139         uint16_t mtu_ = 0;
140     };
141     ObexServerSocketTransport(const Option &option, ObexTransportObserver &observer, utility::Dispatcher &dispatcher);
142     ~ObexServerSocketTransport() override = default;
143     int Listen() override;
144     int Disconnect() override;
145     int Disconnect(ObexTransport &subTransport) override;
146 
147     // Server accept the connection request
148     int AcceptConnection(ObexIncomingConnect &incomingConnect) override;
149     // Server reject the connection request
150     int RejectConnection(ObexIncomingConnect &incomingConnect) override;
151     // get transport key
152     const std::string &GetTransportKey() override;
153 
154 private:
155     static const uint8_t TRANSPORT_KEY_NUM_LEN = 4;
156 
157     class TransportObserver : public DataTransportObserver {
158     public:
159         explicit TransportObserver(ObexServerSocketTransport &mainTran);
160         virtual ~TransportObserver() = default;
161         // The event is triggered when server accept a new connection.
162         void OnConnectIncoming(const RawAddress &addr, uint16_t port) override;
163         // The event is triggered when new connection disconnect before accept.
164         void OnIncomingDisconnected(const RawAddress &addr) override;
165         // The event is triggered when connection complete successfully.
166         void OnConnected(DataTransport *transport, uint16_t sendMTU, uint16_t recvMTU) override;
167         // The event is triggered when a disconnect request is received.
168         void OnDisconnected(DataTransport *transport) override;
169         // The event is triggered when the disconnection process is successful.
170         void OnDisconnectSuccess(DataTransport *transport) override;
171         // The event is triggered when data is received from stack.
172         void OnDataAvailable(DataTransport *transport, Packet *pkt) override;
173         void OnDataAvailable(DataTransport *transport) override;
174         // The event is triggered when peer or RFCOMM/L2CAP is not available to receive data.
175         void OnDataBusy(DataTransport *transport, uint8_t isBusy) override;
176         // The event is triggered when process is failed.
177         void OnTransportError(DataTransport *transport, int errType) override;
178 
179     private:
180         ObexServerSocketTransport &mainTran_;
181         // The event is triggered when server accept a new connection.
182         void ProcessOnConnectIncoming(RawAddress btAddr, uint16_t port);
183         // The event is triggered when new connection disconnect before accept.
184         void ProcessOnIncomingDisconnected(RawAddress btAddr);
185         // The event is triggered when connection complete successfully.
186         void ProcessOnConnected(DataTransport *transport, uint16_t sendMTU, uint16_t recvMTU);
187         // The event is triggered when a disconnect request is received.
188         void ProcessOnDisconnected(DataTransport *transport);
189         // The event is triggered when the disconnection process is successful.
190         void ProcessOnDisconnectSuccess(DataTransport *transport);
191         // The event is triggered when data is received from stack.
192         void ProcessOnDataAvailable(DataTransport *transport, Packet *pkt);
193         // The event is triggered when peer or RFCOMM/L2CAP is not available to receive data.
194         void ProcessOnDataBusy(DataTransport *transport, uint8_t isBusy);
195         // The event is triggered when process is failed.
196         void ProcessOnTransportError(DataTransport *transport, int errType);
197         BT_DISALLOW_COPY_AND_ASSIGN(TransportObserver);
198     };
199     static std::string MakeTransportKey(bool isGoepL2capPSM, uint16_t scn);
200     std::unique_ptr<TransportObserver> transportObserver_ = nullptr;
201     std::unique_ptr<DataTransport> dataTransport_ = nullptr;
202 
203     std::unordered_map<DataTransport *, std::unique_ptr<ObexSocketTransport>> subTranMap_ {};
204     std::unordered_map<std::string, std::unique_ptr<ObexIncomingConnect>> incomingConnectMap_ {};
205     std::string tranKey_ = "";
206     std::atomic_bool isOnListening_ {false};
207     utility::Dispatcher &dispatcher_;
208     BT_DISALLOW_COPY_AND_ASSIGN(ObexServerSocketTransport);
209 };
210 class ObexServerIncomingConnect : public ObexIncomingConnect {
211 public:
212     ObexServerIncomingConnect(ObexServerSocketTransport &obexTransport, const RawAddress &btAddr, int port);
213     virtual ~ObexServerIncomingConnect();
214     //  accept the connection request
215     int AcceptConnection() override;
216     //  reject the connection request
217     int RejectConnection() override;
218     // This function is used to get the Bluetooth address of the peer of the connected channel
219     const RawAddress &GetRemoteAddress() override;
220     // Port
221     int GetPort() override;
222 
223 private:
224     ObexServerSocketTransport &obexTransport_;
225     RawAddress btAddr_ {""};
226     uint16_t port_ = 0;
227     bool operDone_ = false;
228     BT_DISALLOW_COPY_AND_ASSIGN(ObexServerIncomingConnect);
229 };
230 }  // namespace bluetooth
231 }  // namespace OHOS
232 #endif  // OBEX_SOCKET_TRANSPORT_H
233