356 lines
13 KiB
C
356 lines
13 KiB
C
|
/*
|
||
|
|
* Copyright 2012 The WebRTC Project Authors. All rights reserved.
|
||
|
|
*
|
||
|
|
* Use of this source code is governed by a BSD-style license
|
||
|
|
* that can be found in the LICENSE file in the root of the source
|
||
|
|
* tree. An additional intellectual property rights grant can be found
|
||
|
|
* in the file PATENTS. All contributing project authors may
|
||
|
|
* be found in the AUTHORS file in the root of the source tree.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#ifndef P2P_BASE_TURN_SERVER_H_
|
||
|
|
#define P2P_BASE_TURN_SERVER_H_
|
||
|
|
|
||
|
|
#include <list>
|
||
|
|
#include <map>
|
||
|
|
#include <memory>
|
||
|
|
#include <set>
|
||
|
|
#include <string>
|
||
|
|
#include <utility>
|
||
|
|
#include <vector>
|
||
|
|
|
||
|
|
#include "p2p/base/port_interface.h"
|
||
|
|
#include "rtc_base/async_invoker.h"
|
||
|
|
#include "rtc_base/async_packet_socket.h"
|
||
|
|
#include "rtc_base/socket_address.h"
|
||
|
|
#include "rtc_base/third_party/sigslot/sigslot.h"
|
||
|
|
#include "rtc_base/thread.h"
|
||
|
|
#include "rtc_base/thread_checker.h"
|
||
|
|
|
||
|
|
namespace rtc {
|
||
|
|
class ByteBufferWriter;
|
||
|
|
class PacketSocketFactory;
|
||
|
|
} // namespace rtc
|
||
|
|
|
||
|
|
namespace cricket {
|
||
|
|
|
||
|
|
class StunMessage;
|
||
|
|
class TurnMessage;
|
||
|
|
class TurnServer;
|
||
|
|
|
||
|
|
// The default server port for TURN, as specified in RFC5766.
|
||
|
|
const int TURN_SERVER_PORT = 3478;
|
||
|
|
|
||
|
|
// Encapsulates the client's connection to the server.
|
||
|
|
class TurnServerConnection {
|
||
|
|
public:
|
||
|
|
TurnServerConnection() : proto_(PROTO_UDP), socket_(NULL) {}
|
||
|
|
TurnServerConnection(const rtc::SocketAddress& src,
|
||
|
|
ProtocolType proto,
|
||
|
|
rtc::AsyncPacketSocket* socket);
|
||
|
|
const rtc::SocketAddress& src() const { return src_; }
|
||
|
|
rtc::AsyncPacketSocket* socket() { return socket_; }
|
||
|
|
bool operator==(const TurnServerConnection& t) const;
|
||
|
|
bool operator<(const TurnServerConnection& t) const;
|
||
|
|
std::string ToString() const;
|
||
|
|
|
||
|
|
private:
|
||
|
|
rtc::SocketAddress src_;
|
||
|
|
rtc::SocketAddress dst_;
|
||
|
|
cricket::ProtocolType proto_;
|
||
|
|
rtc::AsyncPacketSocket* socket_;
|
||
|
|
};
|
||
|
|
|
||
|
|
// Encapsulates a TURN allocation.
|
||
|
|
// The object is created when an allocation request is received, and then
|
||
|
|
// handles TURN messages (via HandleTurnMessage) and channel data messages
|
||
|
|
// (via HandleChannelData) for this allocation when received by the server.
|
||
|
|
// The object self-deletes and informs the server if its lifetime timer expires.
|
||
|
|
class TurnServerAllocation : public rtc::MessageHandler,
|
||
|
|
public sigslot::has_slots<> {
|
||
|
|
public:
|
||
|
|
TurnServerAllocation(TurnServer* server_,
|
||
|
|
rtc::Thread* thread,
|
||
|
|
const TurnServerConnection& conn,
|
||
|
|
rtc::AsyncPacketSocket* server_socket,
|
||
|
|
const std::string& key);
|
||
|
|
~TurnServerAllocation() override;
|
||
|
|
|
||
|
|
TurnServerConnection* conn() { return &conn_; }
|
||
|
|
const std::string& key() const { return key_; }
|
||
|
|
const std::string& transaction_id() const { return transaction_id_; }
|
||
|
|
const std::string& username() const { return username_; }
|
||
|
|
const std::string& origin() const { return origin_; }
|
||
|
|
const std::string& last_nonce() const { return last_nonce_; }
|
||
|
|
void set_last_nonce(const std::string& nonce) { last_nonce_ = nonce; }
|
||
|
|
|
||
|
|
std::string ToString() const;
|
||
|
|
|
||
|
|
void HandleTurnMessage(const TurnMessage* msg);
|
||
|
|
void HandleChannelData(const char* data, size_t size);
|
||
|
|
|
||
|
|
sigslot::signal1<TurnServerAllocation*> SignalDestroyed;
|
||
|
|
|
||
|
|
private:
|
||
|
|
class Channel;
|
||
|
|
class Permission;
|
||
|
|
typedef std::list<Permission*> PermissionList;
|
||
|
|
typedef std::list<Channel*> ChannelList;
|
||
|
|
|
||
|
|
void HandleAllocateRequest(const TurnMessage* msg);
|
||
|
|
void HandleRefreshRequest(const TurnMessage* msg);
|
||
|
|
void HandleSendIndication(const TurnMessage* msg);
|
||
|
|
void HandleCreatePermissionRequest(const TurnMessage* msg);
|
||
|
|
void HandleChannelBindRequest(const TurnMessage* msg);
|
||
|
|
|
||
|
|
void OnExternalPacket(rtc::AsyncPacketSocket* socket,
|
||
|
|
const char* data,
|
||
|
|
size_t size,
|
||
|
|
const rtc::SocketAddress& addr,
|
||
|
|
const int64_t& packet_time_us);
|
||
|
|
|
||
|
|
static int ComputeLifetime(const TurnMessage* msg);
|
||
|
|
bool HasPermission(const rtc::IPAddress& addr);
|
||
|
|
void AddPermission(const rtc::IPAddress& addr);
|
||
|
|
Permission* FindPermission(const rtc::IPAddress& addr) const;
|
||
|
|
Channel* FindChannel(int channel_id) const;
|
||
|
|
Channel* FindChannel(const rtc::SocketAddress& addr) const;
|
||
|
|
|
||
|
|
void SendResponse(TurnMessage* msg);
|
||
|
|
void SendBadRequestResponse(const TurnMessage* req);
|
||
|
|
void SendErrorResponse(const TurnMessage* req,
|
||
|
|
int code,
|
||
|
|
const std::string& reason);
|
||
|
|
void SendExternal(const void* data,
|
||
|
|
size_t size,
|
||
|
|
const rtc::SocketAddress& peer);
|
||
|
|
|
||
|
|
void OnPermissionDestroyed(Permission* perm);
|
||
|
|
void OnChannelDestroyed(Channel* channel);
|
||
|
|
void OnMessage(rtc::Message* msg) override;
|
||
|
|
|
||
|
|
TurnServer* server_;
|
||
|
|
rtc::Thread* thread_;
|
||
|
|
TurnServerConnection conn_;
|
||
|
|
std::unique_ptr<rtc::AsyncPacketSocket> external_socket_;
|
||
|
|
std::string key_;
|
||
|
|
std::string transaction_id_;
|
||
|
|
std::string username_;
|
||
|
|
std::string origin_;
|
||
|
|
std::string last_nonce_;
|
||
|
|
PermissionList perms_;
|
||
|
|
ChannelList channels_;
|
||
|
|
};
|
||
|
|
|
||
|
|
// An interface through which the MD5 credential hash can be retrieved.
|
||
|
|
class TurnAuthInterface {
|
||
|
|
public:
|
||
|
|
// Gets HA1 for the specified user and realm.
|
||
|
|
// HA1 = MD5(A1) = MD5(username:realm:password).
|
||
|
|
// Return true if the given username and realm are valid, or false if not.
|
||
|
|
virtual bool GetKey(const std::string& username,
|
||
|
|
const std::string& realm,
|
||
|
|
std::string* key) = 0;
|
||
|
|
virtual ~TurnAuthInterface() = default;
|
||
|
|
};
|
||
|
|
|
||
|
|
// An interface enables Turn Server to control redirection behavior.
|
||
|
|
class TurnRedirectInterface {
|
||
|
|
public:
|
||
|
|
virtual bool ShouldRedirect(const rtc::SocketAddress& address,
|
||
|
|
rtc::SocketAddress* out) = 0;
|
||
|
|
virtual ~TurnRedirectInterface() {}
|
||
|
|
};
|
||
|
|
|
||
|
|
class StunMessageObserver {
|
||
|
|
public:
|
||
|
|
virtual void ReceivedMessage(const TurnMessage* msg) = 0;
|
||
|
|
virtual void ReceivedChannelData(const char* data, size_t size) = 0;
|
||
|
|
virtual ~StunMessageObserver() {}
|
||
|
|
};
|
||
|
|
|
||
|
|
// The core TURN server class. Give it a socket to listen on via
|
||
|
|
// AddInternalServerSocket, and a factory to create external sockets via
|
||
|
|
// SetExternalSocketFactory, and it's ready to go.
|
||
|
|
// Not yet wired up: TCP support.
|
||
|
|
class TurnServer : public sigslot::has_slots<> {
|
||
|
|
public:
|
||
|
|
typedef std::map<TurnServerConnection, std::unique_ptr<TurnServerAllocation>>
|
||
|
|
AllocationMap;
|
||
|
|
|
||
|
|
explicit TurnServer(rtc::Thread* thread);
|
||
|
|
~TurnServer() override;
|
||
|
|
|
||
|
|
// Gets/sets the realm value to use for the server.
|
||
|
|
const std::string& realm() const {
|
||
|
|
RTC_DCHECK(thread_checker_.IsCurrent());
|
||
|
|
return realm_;
|
||
|
|
}
|
||
|
|
void set_realm(const std::string& realm) {
|
||
|
|
RTC_DCHECK(thread_checker_.IsCurrent());
|
||
|
|
realm_ = realm;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Gets/sets the value for the SOFTWARE attribute for TURN messages.
|
||
|
|
const std::string& software() const {
|
||
|
|
RTC_DCHECK(thread_checker_.IsCurrent());
|
||
|
|
return software_;
|
||
|
|
}
|
||
|
|
void set_software(const std::string& software) {
|
||
|
|
RTC_DCHECK(thread_checker_.IsCurrent());
|
||
|
|
software_ = software;
|
||
|
|
}
|
||
|
|
|
||
|
|
const AllocationMap& allocations() const {
|
||
|
|
RTC_DCHECK(thread_checker_.IsCurrent());
|
||
|
|
return allocations_;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sets the authentication callback; does not take ownership.
|
||
|
|
void set_auth_hook(TurnAuthInterface* auth_hook) {
|
||
|
|
RTC_DCHECK(thread_checker_.IsCurrent());
|
||
|
|
auth_hook_ = auth_hook;
|
||
|
|
}
|
||
|
|
|
||
|
|
void set_redirect_hook(TurnRedirectInterface* redirect_hook) {
|
||
|
|
RTC_DCHECK(thread_checker_.IsCurrent());
|
||
|
|
redirect_hook_ = redirect_hook;
|
||
|
|
}
|
||
|
|
|
||
|
|
void set_enable_otu_nonce(bool enable) {
|
||
|
|
RTC_DCHECK(thread_checker_.IsCurrent());
|
||
|
|
enable_otu_nonce_ = enable;
|
||
|
|
}
|
||
|
|
|
||
|
|
// If set to true, reject CreatePermission requests to RFC1918 addresses.
|
||
|
|
void set_reject_private_addresses(bool filter) {
|
||
|
|
RTC_DCHECK(thread_checker_.IsCurrent());
|
||
|
|
reject_private_addresses_ = filter;
|
||
|
|
}
|
||
|
|
|
||
|
|
void set_enable_permission_checks(bool enable) {
|
||
|
|
RTC_DCHECK(thread_checker_.IsCurrent());
|
||
|
|
enable_permission_checks_ = enable;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Starts listening for packets from internal clients.
|
||
|
|
void AddInternalSocket(rtc::AsyncPacketSocket* socket, ProtocolType proto);
|
||
|
|
// Starts listening for the connections on this socket. When someone tries
|
||
|
|
// to connect, the connection will be accepted and a new internal socket
|
||
|
|
// will be added.
|
||
|
|
void AddInternalServerSocket(rtc::AsyncSocket* socket, ProtocolType proto);
|
||
|
|
// Specifies the factory to use for creating external sockets.
|
||
|
|
void SetExternalSocketFactory(rtc::PacketSocketFactory* factory,
|
||
|
|
const rtc::SocketAddress& address);
|
||
|
|
// For testing only.
|
||
|
|
std::string SetTimestampForNextNonce(int64_t timestamp) {
|
||
|
|
RTC_DCHECK(thread_checker_.IsCurrent());
|
||
|
|
ts_for_next_nonce_ = timestamp;
|
||
|
|
return GenerateNonce(timestamp);
|
||
|
|
}
|
||
|
|
|
||
|
|
void SetStunMessageObserver(std::unique_ptr<StunMessageObserver> observer) {
|
||
|
|
RTC_DCHECK(thread_checker_.IsCurrent());
|
||
|
|
stun_message_observer_ = std::move(observer);
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
std::string GenerateNonce(int64_t now) const;
|
||
|
|
void OnInternalPacket(rtc::AsyncPacketSocket* socket,
|
||
|
|
const char* data,
|
||
|
|
size_t size,
|
||
|
|
const rtc::SocketAddress& address,
|
||
|
|
const int64_t& packet_time_us);
|
||
|
|
|
||
|
|
void OnNewInternalConnection(rtc::AsyncSocket* socket);
|
||
|
|
|
||
|
|
// Accept connections on this server socket.
|
||
|
|
void AcceptConnection(rtc::AsyncSocket* server_socket);
|
||
|
|
void OnInternalSocketClose(rtc::AsyncPacketSocket* socket, int err);
|
||
|
|
|
||
|
|
void HandleStunMessage(TurnServerConnection* conn,
|
||
|
|
const char* data,
|
||
|
|
size_t size);
|
||
|
|
void HandleBindingRequest(TurnServerConnection* conn, const StunMessage* msg);
|
||
|
|
void HandleAllocateRequest(TurnServerConnection* conn,
|
||
|
|
const TurnMessage* msg,
|
||
|
|
const std::string& key);
|
||
|
|
|
||
|
|
bool GetKey(const StunMessage* msg, std::string* key);
|
||
|
|
bool CheckAuthorization(TurnServerConnection* conn,
|
||
|
|
const StunMessage* msg,
|
||
|
|
const char* data,
|
||
|
|
size_t size,
|
||
|
|
const std::string& key);
|
||
|
|
bool ValidateNonce(const std::string& nonce) const;
|
||
|
|
|
||
|
|
TurnServerAllocation* FindAllocation(TurnServerConnection* conn);
|
||
|
|
TurnServerAllocation* CreateAllocation(TurnServerConnection* conn,
|
||
|
|
int proto,
|
||
|
|
const std::string& key);
|
||
|
|
|
||
|
|
void SendErrorResponse(TurnServerConnection* conn,
|
||
|
|
const StunMessage* req,
|
||
|
|
int code,
|
||
|
|
const std::string& reason);
|
||
|
|
|
||
|
|
void SendErrorResponseWithRealmAndNonce(TurnServerConnection* conn,
|
||
|
|
const StunMessage* req,
|
||
|
|
int code,
|
||
|
|
const std::string& reason);
|
||
|
|
|
||
|
|
void SendErrorResponseWithAlternateServer(TurnServerConnection* conn,
|
||
|
|
const StunMessage* req,
|
||
|
|
const rtc::SocketAddress& addr);
|
||
|
|
|
||
|
|
void SendStun(TurnServerConnection* conn, StunMessage* msg);
|
||
|
|
void Send(TurnServerConnection* conn, const rtc::ByteBufferWriter& buf);
|
||
|
|
|
||
|
|
void OnAllocationDestroyed(TurnServerAllocation* allocation);
|
||
|
|
void DestroyInternalSocket(rtc::AsyncPacketSocket* socket);
|
||
|
|
|
||
|
|
// Just clears |sockets_to_delete_|; called asynchronously.
|
||
|
|
void FreeSockets();
|
||
|
|
|
||
|
|
typedef std::map<rtc::AsyncPacketSocket*, ProtocolType> InternalSocketMap;
|
||
|
|
typedef std::map<rtc::AsyncSocket*, ProtocolType> ServerSocketMap;
|
||
|
|
|
||
|
|
rtc::Thread* thread_;
|
||
|
|
rtc::ThreadChecker thread_checker_;
|
||
|
|
std::string nonce_key_;
|
||
|
|
std::string realm_;
|
||
|
|
std::string software_;
|
||
|
|
TurnAuthInterface* auth_hook_;
|
||
|
|
TurnRedirectInterface* redirect_hook_;
|
||
|
|
// otu - one-time-use. Server will respond with 438 if it's
|
||
|
|
// sees the same nonce in next transaction.
|
||
|
|
bool enable_otu_nonce_;
|
||
|
|
bool reject_private_addresses_ = false;
|
||
|
|
// Check for permission when receiving an external packet.
|
||
|
|
bool enable_permission_checks_ = true;
|
||
|
|
|
||
|
|
InternalSocketMap server_sockets_;
|
||
|
|
ServerSocketMap server_listen_sockets_;
|
||
|
|
// Used when we need to delete a socket asynchronously.
|
||
|
|
std::vector<std::unique_ptr<rtc::AsyncPacketSocket>> sockets_to_delete_;
|
||
|
|
std::unique_ptr<rtc::PacketSocketFactory> external_socket_factory_;
|
||
|
|
rtc::SocketAddress external_addr_;
|
||
|
|
|
||
|
|
AllocationMap allocations_;
|
||
|
|
|
||
|
|
rtc::AsyncInvoker invoker_;
|
||
|
|
|
||
|
|
// For testing only. If this is non-zero, the next NONCE will be generated
|
||
|
|
// from this value, and it will be reset to 0 after generating the NONCE.
|
||
|
|
int64_t ts_for_next_nonce_ = 0;
|
||
|
|
|
||
|
|
// For testing only. Used to observe STUN messages received.
|
||
|
|
std::unique_ptr<StunMessageObserver> stun_message_observer_;
|
||
|
|
|
||
|
|
friend class TurnServerAllocation;
|
||
|
|
};
|
||
|
|
|
||
|
|
} // namespace cricket
|
||
|
|
|
||
|
|
#endif // P2P_BASE_TURN_SERVER_H_
|