368 lines
12 KiB
C++
368 lines
12 KiB
C++
/* Copyright(C) 2007-2014 VoIP objects (voipobjects.com)
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifndef __ICE_STREAM_H
|
|
#define __ICE_STREAM_H
|
|
|
|
#include <map>
|
|
#include <vector>
|
|
|
|
#include "ICEBox.h"
|
|
#include "ICECandidate.h"
|
|
#include "ICEStunConfig.h"
|
|
#include "ICEAction.h"
|
|
#include "ICEStunTransaction.h"
|
|
#include "ICECheckList.h"
|
|
#include "ICEBinding.h"
|
|
#include "ICETime.h"
|
|
#include "ICETransactionList.h"
|
|
#include "ICERelaying.h"
|
|
|
|
namespace ice
|
|
{
|
|
enum Failover
|
|
{
|
|
FailoverOn = 1,
|
|
FailoverOff = 2
|
|
};
|
|
|
|
// Session state
|
|
enum RunningState
|
|
{
|
|
None = 0,
|
|
CandidateGathering,
|
|
EliminateRedudand,
|
|
ComputingFoundations,
|
|
StartingKeepAlives,
|
|
PrioritizingCandidates,
|
|
ChoosingDefault,
|
|
CreatingSDP,
|
|
ConnCheck,
|
|
Failed,
|
|
Success
|
|
};
|
|
|
|
extern const char* RunningStateToString(RunningState state);
|
|
|
|
// Smart pointer to ICE stream type
|
|
typedef std::shared_ptr<Stream> ICEStreamPtr;
|
|
|
|
|
|
// Map of used channel TURN prefixes as key and corresponding address as value
|
|
typedef std::map<TurnPrefix, NetworkAddress> TurnPrefixMap;
|
|
|
|
struct Component
|
|
{
|
|
void* mTag;
|
|
unsigned short mPort4;
|
|
unsigned short mPort6;
|
|
unsigned mNominationWaitIntervalStartTime;
|
|
Component()
|
|
:mTag(NULL), mPort4(0), mPort6(0), mNominationWaitIntervalStartTime(0)
|
|
{}
|
|
|
|
~Component()
|
|
{
|
|
}
|
|
};
|
|
|
|
typedef std::map<int, Component> ComponentMap;
|
|
|
|
// Represents single ICE stream with single or multiple components (sockets)
|
|
struct Stream
|
|
{
|
|
// Stream id
|
|
int mId;
|
|
|
|
// Stack ID. Used for debugging purposes.
|
|
int mStackId;
|
|
|
|
// Map of component ID -> user tag
|
|
ComponentMap mComponentMap;
|
|
|
|
// List of local candidates and list of remote candidates
|
|
typedef std::vector<Candidate> CandidateVector;
|
|
CandidateVector mLocalCandidate, mRemoteCandidate, mRemoteRelayedCandidate;
|
|
|
|
// Check list
|
|
CheckList mCheckList;
|
|
|
|
// Logger
|
|
Logger* mLogger;
|
|
|
|
// Foundation generator value to provide foundation value for peer reflexive candidates
|
|
unsigned int mFoundationGenerator;
|
|
|
|
// Active STUN transactions. This vector includes connectivity check transactions and gather candidates transactions.
|
|
// Keepalive transactions are stored in mKeepAliveList
|
|
TransactionList mActiveChecks;
|
|
|
|
// ICE agent role
|
|
AgentRole mAgentRole;
|
|
|
|
// Map of established relay channels
|
|
TurnPrefixMap mTurnPrefixMap;
|
|
|
|
// Current state of media stream
|
|
RunningState mState;
|
|
|
|
// Used configuration
|
|
StackConfig mConfig;
|
|
|
|
// Helper vector used to prioritize candidates
|
|
std::vector<unsigned> mComponentLimit;
|
|
|
|
// Default candidate list - one per each component
|
|
std::map<int, Candidate> mDefaultCandidate;
|
|
|
|
// Local password/ufrag
|
|
std::string mLocalPwd;
|
|
std::string mLocalUfrag;
|
|
|
|
// Remote password/ufrag
|
|
std::string mRemotePwd;
|
|
std::string mRemoteUfrag;
|
|
|
|
// Marks if selected during connectivity checks default IP list differs from used to generate offer
|
|
bool mDefaultIPChanged;
|
|
|
|
// Marks if checks was ok for this stream and each component has valid nominated pair
|
|
bool mCanTransmit;
|
|
|
|
std::vector<ByteBuffer*> mResponseQueue;
|
|
// Tie breaker
|
|
std::string mTieBreaker;
|
|
|
|
// Timer to schedule connection checks (CC)
|
|
ICEScheduleTimer mScheduleTimer;
|
|
|
|
// Counter of TURN allocations
|
|
int mTurnAllocated;
|
|
|
|
// Last error code during gathering/checks
|
|
int mErrorCode;
|
|
|
|
// Cached realm and nonce for used TURN server
|
|
std::string mCachedRealm, mCachedNonce;
|
|
|
|
// Timestamp of nomination waiting timer. Used to accumulate valid pairs and chose the "best" of them.
|
|
unsigned mNominationWaitStartTime;
|
|
|
|
// Number of finished failover gathering requests
|
|
int mFailoverRequestsFinished;
|
|
|
|
// Failover ID generator. Failover transactions which share the same goal share the same ID.
|
|
int mFailoverIdGenerator;
|
|
|
|
struct BoundChannel
|
|
{
|
|
int mComponentId;
|
|
TurnPrefix mPrefix;
|
|
NetworkAddress mPeerAddress;
|
|
int mResultCode;
|
|
};
|
|
typedef std::vector<BoundChannel> BoundChannelList;
|
|
BoundChannelList mBoundChannelList;
|
|
|
|
// Create Allocate transaction and associate with passed action
|
|
struct AllocateOptions
|
|
{
|
|
NetworkAddress mServerAddress;
|
|
PAction mActionOnFinish;
|
|
int mComponent = 0;
|
|
Failover mFailoverOption = FailoverOn;
|
|
int mWireFamily = AF_INET;
|
|
int mAllocFamily = AF_INET;
|
|
int mFailoverId = 0;
|
|
};
|
|
void allocate(const AllocateOptions& options);
|
|
|
|
// Create Bind transaction and associate with passed action
|
|
void bind(const NetworkAddress& addr, PAction action, bool auth, int component, Failover failover);
|
|
|
|
// Searches for local candidate with specified address
|
|
unsigned findLocalCandidate(const NetworkAddress& addr);
|
|
|
|
// Cancels found transaction.
|
|
void cancelCheck(CandidatePair& p);
|
|
|
|
// Cancels allocations
|
|
void cancelAllocations();
|
|
|
|
// Searches for remote candidate with specified remote address and corresponding to local port number
|
|
unsigned findRemoteCandidate(const NetworkAddress& addr, int componentID);
|
|
|
|
// Process incoming binding request
|
|
void handleBindingRequest(ServerBinding& binding, ByteBuffer& buffer, int component);
|
|
|
|
// Handles incoming data in gathering candidate stage.
|
|
bool handleCgIn(StunMessage& msg, NetworkAddress& address);
|
|
|
|
// Handle eliminate redudand stage
|
|
void Handle_ER();
|
|
|
|
// Compute foundations
|
|
void Handle_CF();
|
|
|
|
// Starting keep alive timers
|
|
void Handle_SKA();
|
|
|
|
// Prioritize candidates
|
|
void Handle_PC();
|
|
|
|
// Choosing default candidate
|
|
void Handle_CD();
|
|
|
|
// Handles keepalive messages
|
|
//bool handleKeepAlivesIn(StunMessage& msg, NetworkAddress& address);
|
|
|
|
// Handles incoming messages in connectivity checks stage
|
|
// This method uses Handle_KA_In to perform keepalive handling
|
|
bool handleConnChecksIn(StunMessage& msg, NetworkAddress& address);
|
|
|
|
// Handle incoming Bind request
|
|
void handleIncomingRequest(StunMessage& msg, ByteBuffer& buffer, int component);
|
|
|
|
// Chooses default candidate for specified component ID
|
|
Candidate findDefaultCandidate(int componentID);
|
|
|
|
//Performs 8.1.2. Updating States
|
|
void checkNominated(int componentID);
|
|
void checkNominated();
|
|
bool handleRoleConflict(ServerBinding& binding);
|
|
|
|
//Checks active transactions (keepalive and ordinary) for timeouts
|
|
void isTimeout();
|
|
|
|
// Checks for next byte buffer for sending
|
|
ByteBuffer* handleConnChecksOut();
|
|
|
|
// Creates connectivity check request for specified pair.
|
|
Transaction* createCheckRequest(PCandidatePair& p);
|
|
|
|
// Checks for TURN channel prefix by specified peer's address.
|
|
// Returns zero prefix if it is not found.
|
|
TurnPrefix findTurnPrefixByAddress(NetworkAddress& peerAddress);
|
|
|
|
// Create candidate pair in check list.
|
|
void createCheckList();
|
|
|
|
// Starts connectivity checks - calls Create_CheckList to create check list + starts retransmission timer
|
|
void startChecks();
|
|
|
|
// Stops connectivity checks and gathering requests
|
|
void stopChecks();
|
|
|
|
// Initiates ChannelBind transaction to TURN server.
|
|
TurnPrefix bindChannel(const NetworkAddress& peerAddress, int component, ChannelBoundCallback* cb = NULL);
|
|
bool isChannelBindingFailed(int component, TurnPrefix prefix);
|
|
void removeBindingResult(int component);
|
|
|
|
// Attempts to free allocation.
|
|
void freeAllocation(int component, DeleteAllocationCallback* cb = NULL);
|
|
|
|
// Searches for local server reflexive candidate with specified component ID and returns its external address.
|
|
NetworkAddress reflexiveAddress(int componentID);
|
|
|
|
/*! Searches for local server relayed candidate with specified component ID and returns its external address. */
|
|
NetworkAddress relayedAddress(int componentID);
|
|
|
|
// Searches for remote server relayed candidate with specified component
|
|
NetworkAddress remoteRelayedAddress(int component);
|
|
|
|
// Searches for remote server reflexive candidate with specified component
|
|
NetworkAddress remoteReflexiveAddress(int component);
|
|
|
|
|
|
Stream();
|
|
~Stream();
|
|
|
|
// Sets config
|
|
void setConfig(StackConfig& config);
|
|
|
|
// Sets ICE agent role - Controlled or Controlling
|
|
void setAgentRole(AgentRole role);
|
|
|
|
// Sets local password
|
|
void setLocalPwd(const std::string& pwd);
|
|
|
|
// Sets local ufrag
|
|
void setLocalUfrag(const std::string& ufrag);
|
|
|
|
// Sets remote password
|
|
void setRemotePwd(const std::string& pwd);
|
|
|
|
// Sets remote ufrag
|
|
void setRemoteUfrag(const std::string& ufrag);
|
|
|
|
// Sets tie breaker
|
|
void setTieBreaker(const std::string& tieBreaker);
|
|
|
|
// Adds new component to stream
|
|
int addComponent(void* tag, unsigned short port4, unsigned short port6);
|
|
|
|
// Gathers candidates for stream
|
|
void gatherCandidates();
|
|
|
|
// Returns reference to check list
|
|
CheckList& checkList();
|
|
|
|
// Check is stream owns specified port number
|
|
bool hasPortNumber(int family, unsigned short portNumber, int* component = NULL);
|
|
|
|
// Processes incoming data
|
|
bool processData(StunMessage& msg, ByteBuffer& buffer, int component);
|
|
|
|
void createOfferSdp(std::vector<std::string>& defaultIP, std::vector<unsigned short>& defaultPort,
|
|
std::vector<std::string>& candidateList);
|
|
|
|
NetworkAddress defaultAddress(int componentID);
|
|
void candidateList(int componentID, std::vector<std::string>& candidateList);
|
|
|
|
PByteBuffer getDataToSend(bool& response, int& component, void*&tag);
|
|
|
|
// Constructs new keepalive transaction and adds to mKeepAlives
|
|
void addKeepAliveCheck(CandidatePair& p);
|
|
|
|
// Processes SDP offer, adding remote candidates from it
|
|
bool processSdpOffer(std::vector<std::string>& candidateList, std::string defaultIP, unsigned short defaultPort, bool deleteRelayed);
|
|
|
|
// Checks if remote candidate list contains specified address
|
|
bool candidateListContains(const std::string& remoteIP, unsigned short remotePort);
|
|
|
|
// Restarts stream's connectivity checks
|
|
void restart();
|
|
|
|
// Clears the stack; resets state to None. The free allocation requests are left in the queue
|
|
void clear();
|
|
|
|
// Deletes existing connectivity checks and resets turn allocation counters
|
|
void clearForRestart(bool localNetworkChanged);
|
|
|
|
// Returns resolved address of remote party identified by its componmentID
|
|
NetworkAddress remoteAddress(int component);
|
|
NetworkAddress localAddress(int component);
|
|
|
|
void installPermissions(int component = -1, const NetworkAddress& addr = NetworkAddress(), InstallPermissionsCallback* cb = NULL);
|
|
void dump(std::ostream& output);
|
|
bool findConcludePair(Candidate& local, Candidate& remote);
|
|
int findComponentIdByPort(unsigned short port, int family);
|
|
Transaction* runCheckList(CandidatePair::Role role, CandidatePair::State state);
|
|
void deleteTransactionAt(unsigned index);
|
|
void clearChecks();
|
|
|
|
void dumpLocalCandidateList();
|
|
void processStateChain();
|
|
|
|
// Disables (removes) active transactions responsible for gathering candidates - binding & allocating
|
|
void removeGatherRequests(int component, int failoverId, Transaction* validOne);
|
|
void unfreeze(const char* foundation);
|
|
void nominatePair(PCandidatePair& p);
|
|
bool ressurectAllocation(int component);
|
|
};
|
|
}
|
|
|
|
#endif
|