mirror of
https://gitlab.linphone.org/BC/public/linphone-iphone.git
synced 2026-01-23 22:28:07 +00:00
4bc67e3645
If this parameter is set to 1, SIP packets will pass through tunnels when the tunnel mode is enabled. If set to 0, SIP packets will be directly sent to proxies whatever the state of tunnels
221 lines
7.8 KiB
C++
221 lines
7.8 KiB
C++
/*
|
|
* C Implementation: tunnel
|
|
*
|
|
* Description:
|
|
*
|
|
*
|
|
*
|
|
*Copyright (C) 2011 Belledonne Comunications, Grenoble, France
|
|
*/
|
|
|
|
#ifndef __TUNNEL_CLIENT_MANAGER_H__
|
|
#define __TUNNEL_CLIENT_MANAGER_H__
|
|
#include <list>
|
|
#include <string>
|
|
#include "tunnel/client.hh"
|
|
#include "linphonecore.h"
|
|
|
|
#ifndef USE_BELLESIP
|
|
extern "C" {
|
|
#include "eXosip2/eXosip_transport_hook.h"
|
|
}
|
|
#endif
|
|
|
|
namespace belledonnecomm {
|
|
class TunnelClient;
|
|
class UdpMirrorClient;
|
|
/**
|
|
* @addtogroup tunnel_client
|
|
* @{
|
|
**/
|
|
|
|
/**
|
|
* The TunnelManager class extends the LinphoneCore functionnality in order to provide an easy to use API to
|
|
* - provision tunnel servers ip addresses and ports
|
|
* - start/stop the tunneling service
|
|
* - be informed of connection and disconnection events to the tunnel server
|
|
* - perform auto-detection whether tunneling is required, based on a test of sending/receiving a flow of UDP packets.
|
|
*
|
|
* It takes in charge automatically the SIP registration procedure when connecting or disconnecting to a tunnel server.
|
|
* No other action on LinphoneCore is required to enable full operation in tunnel mode.
|
|
**/
|
|
class TunnelManager : public TunnelClientController{
|
|
|
|
public:
|
|
/**
|
|
* Add a tunnel server. At least one should be provided to be able to connect.
|
|
* When several addresses are provided, the tunnel client may try each of them until it gets connected.
|
|
*
|
|
* @param ip tunnMethod definition for '-isInitialStateOn' not foundel server ip address
|
|
* @param port tunnel server tls port, recommended value is 443
|
|
*/
|
|
void addServer(const char *ip, int port);
|
|
/**
|
|
*Add tunnel server with auto detection capabilities
|
|
*
|
|
* @param ip tunnel server ip address
|
|
* @param port tunnel server tls port, recommended value is 443
|
|
* @param udpMirrorPort remote port on the tunnel server side used to test udp reachability
|
|
* @param delay udp packet round trip delay in ms considered as acceptable. recommanded value is 1000 ms.
|
|
*/
|
|
void addServer(const char *ip, int port,unsigned int udpMirrorPort,unsigned int delay);
|
|
/**
|
|
* Removes all tunnel server address previously entered with addServer()
|
|
**/
|
|
void cleanServers();
|
|
/**
|
|
* Register a state callback to be notified whenever the tunnel client is connected or disconnected to the tunnel server.
|
|
* @param cb application callback function to use for notifying of connection/disconnection events.
|
|
* @param userdata An opaque pointer passed to the callback, used optionally by the application to retrieve a context.
|
|
**/
|
|
void setCallback(StateCallback cb, void *userdata);
|
|
/**
|
|
* Start connecting to a tunnel server.
|
|
* At this step, nothing is tunneled yet. The enable() method must be used to state whether SIP and RTP traffic
|
|
* need to be tunneled or not.
|
|
**/
|
|
void start();
|
|
/**
|
|
* Forces reconnection to the tunnel server.
|
|
* This method is useful when the device switches from wifi to Edge/3G or vice versa. In most cases the tunnel client socket
|
|
* won't be notified promptly that its connection is now zombie, so it is recommended to call this method that will cause
|
|
* the lost connection to be closed and new connection to be issued.
|
|
**/
|
|
void reconnect();
|
|
/**
|
|
* Sets whether tunneling of SIP and RTP is required.
|
|
* @param isEnabled If true enter in tunneled mode, if false exits from tunneled mode.
|
|
* The TunnelManager takes care of refreshing SIP registration when switching on or off the tunneled mode.
|
|
*
|
|
**/
|
|
void enable(bool isEnabled);
|
|
/**
|
|
* In auto detect mode, the tunnel manager try to establish a real time rtp cummunication with the tunnel server on specified port.
|
|
*<br/>In case of success, the tunnel is automatically turned off. Otherwise, if no udp commmunication is feasible, tunnel mode is turned on.
|
|
*<br/> Call this method each time to run the auto detection algorithm
|
|
*/
|
|
void autoDetect();
|
|
/**
|
|
* Returns a boolean indicating whether tunneled operation is enabled.
|
|
**/
|
|
bool isEnabled() const;
|
|
/**
|
|
* Enables debug logs of the Tunnel subsystem.
|
|
**/
|
|
void enableLogs(bool isEnabled);
|
|
/**
|
|
* Enables debugs logs of the Tunnel subsystem and specify a callback where to receive the debug messages.
|
|
**/
|
|
void enableLogs(bool isEnabled,LogHandler logHandler);
|
|
/**
|
|
* iOS only feature: specify http proxy credentials.
|
|
* When the iOS device has an http proxy configured in the iOS settings, the tunnel client will connect to the server
|
|
* through this http proxy. Credentials might be needed depending on the proxy configuration.
|
|
* @param username The username.
|
|
* @param passwd The password.
|
|
**/
|
|
void setHttpProxyAuthInfo(const char* username,const char* passwd);
|
|
/**
|
|
* Indicate to the tunnel manager whether SIP packets must pass
|
|
* through the tunnel. That featurte is automatically enabled at
|
|
* the creation of the TunnelManager instance.
|
|
* @param enable If set to TRUE, SIP packets will pass through the tunnel.
|
|
* If set to FALSE, SIP packets will pass by the configured proxies.
|
|
*/
|
|
void tunnelizeSipPackets(bool enable);
|
|
/**
|
|
* @brief Check whether the tunnel manager is set to tunnelize SIP packets
|
|
* @return True, SIP packets pass through the tunnel
|
|
*/
|
|
bool tunnelizeSipPacketsEnabled() const;
|
|
/**
|
|
* @brief Destructor
|
|
*/
|
|
~TunnelManager();
|
|
/**
|
|
* @brief Constructor
|
|
* @param lc The LinphoneCore instance of which the TunnelManager will be associated to.
|
|
*/
|
|
TunnelManager(LinphoneCore* lc);
|
|
/**
|
|
* Destroy the given RtpTransport.
|
|
*/
|
|
void closeRtpTransport(RtpTransport *t, TunnelSocket *s);
|
|
|
|
/**
|
|
* Create an RtpTransport.
|
|
*/
|
|
RtpTransport *createRtpTransport(int port);
|
|
|
|
/**
|
|
* Get associated Linphone Core.
|
|
*/
|
|
LinphoneCore *getLinphoneCore() const;
|
|
virtual void setHttpProxy(const char *host,int port, const char *username, const char *passwd);
|
|
virtual bool isReady() const;
|
|
private:
|
|
enum EventType{
|
|
UdpMirrorClientEvent,
|
|
TunnelEvent,
|
|
};
|
|
struct Event{
|
|
EventType mType;
|
|
union EventData{
|
|
bool mConnected;
|
|
bool mHaveUdp;
|
|
}mData;
|
|
};
|
|
typedef std::list<UdpMirrorClient> UdpMirrorClientList;
|
|
virtual bool isStarted() const;
|
|
void onIterate();
|
|
static int customSendto(struct _RtpTransport *t, mblk_t *msg , int flags, const struct sockaddr *to, socklen_t tolen);
|
|
static int customRecvfrom(struct _RtpTransport *t, mblk_t *msg, int flags, struct sockaddr *from, socklen_t *fromlen);
|
|
static int eXosipSendto(int fd,const void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen,void* userdata);
|
|
static int eXosipRecvfrom(int fd, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen,void* userdata);
|
|
static int eXosipSelect(int nfds, fd_set *s1, fd_set *s2, fd_set *s3, struct timeval *tv,void* userdata);
|
|
static void tunnelCallback(bool connected, TunnelManager *zis);
|
|
static void sOnIterate(TunnelManager *zis);
|
|
static void sUdpMirrorClientCallback(bool result, void* data);
|
|
void registration();
|
|
void waitUnRegistration();
|
|
void processTunnelEvent(const Event &ev);
|
|
void processUdpMirrorEvent(const Event &ev);
|
|
void postEvent(const Event &ev);
|
|
void stopClient();
|
|
|
|
private:
|
|
LinphoneCore* mCore;
|
|
#ifndef USE_BELLESIP
|
|
TunnelSocket *mSipSocket;
|
|
eXosip_transport_hooks_t mExosipTransport;
|
|
#endif
|
|
StateCallback mCallback;
|
|
void * mCallbackData;
|
|
bool mEnabled;
|
|
std::queue<Event> mEvq;
|
|
std::list <ServerAddr> mServerAddrs;
|
|
UdpMirrorClientList mUdpMirrorClients;
|
|
UdpMirrorClientList::iterator mCurrentUdpMirrorClient;
|
|
TunnelClient* mTunnelClient;
|
|
Mutex mMutex;
|
|
static Mutex sMutex;
|
|
bool mAutoDetectStarted;
|
|
bool mReady;
|
|
LinphoneRtpTransportFactories mTransportFactories;
|
|
std::string mHttpUserName;
|
|
std::string mHttpPasswd;
|
|
std::string mHttpProxyHost;
|
|
int mHttpProxyPort;
|
|
bool mPreviousRegistrationEnabled;
|
|
bool mTunnelizeSipPackets;
|
|
};
|
|
|
|
/**
|
|
* @}
|
|
**/
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /*__TUNNEL_CLIENT_MANAGER_H__*/
|