Yate
|
00001 /* 00002 * yatertp.h 00003 * Yet Another RTP Stack 00004 * This file is part of the YATE Project http://YATE.null.ro 00005 * 00006 * Yet Another Telephony Engine - a fully featured software PBX and IVR 00007 * Copyright (C) 2004-2006 Null Team 00008 * 00009 * This program is free software; you can redistribute it and/or modify 00010 * it under the terms of the GNU General Public License as published by 00011 * the Free Software Foundation; either version 2 of the License, or 00012 * (at your option) any later version. 00013 * 00014 * This program is distributed in the hope that it will be useful, 00015 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00016 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00017 * GNU General Public License for more details. 00018 * 00019 * You should have received a copy of the GNU General Public License 00020 * along with this program; if not, write to the Free Software 00021 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. 00022 */ 00023 00024 #ifndef __YATERTP_H 00025 #define __YATERTP_H 00026 00027 #include <yateclass.h> 00028 00029 #ifdef _WINDOWS 00030 00031 #ifdef LIBYRTP_EXPORTS 00032 #define YRTP_API __declspec(dllexport) 00033 #else 00034 #ifndef LIBYRTP_STATIC 00035 #define YRTP_API __declspec(dllimport) 00036 #endif 00037 #endif 00038 00039 #endif /* _WINDOWS */ 00040 00041 #ifndef YRTP_API 00042 #define YRTP_API 00043 #endif 00044 00048 namespace TelEngine { 00049 00050 class RTPGroup; 00051 class RTPTransport; 00052 class RTPSession; 00053 class RTPSender; 00054 class RTPReceiver; 00055 class RTPSecure; 00056 00061 class YRTP_API RTPProcessor : public GenObject 00062 { 00063 friend class UDPSession; 00064 friend class UDPTLSession; 00065 friend class RTPGroup; 00066 friend class RTPTransport; 00067 friend class RTPSender; 00068 friend class RTPReceiver; 00069 00070 public: 00074 RTPProcessor(); 00075 00079 virtual ~RTPProcessor(); 00080 00085 inline RTPGroup* group() const 00086 { return m_group; } 00087 00093 virtual void rtpData(const void* data, int len); 00094 00100 virtual void rtcpData(const void* data, int len); 00101 00106 virtual void getStats(String& stats) const; 00107 00108 protected: 00113 void group(RTPGroup* newgrp); 00114 00119 virtual void timerTick(const Time& when) = 0; 00120 00121 private: 00122 RTPGroup* m_group; 00123 }; 00124 00130 class YRTP_API RTPGroup : public GenObject, public Mutex, public Thread 00131 { 00132 friend class RTPProcessor; 00133 00134 public: 00140 RTPGroup(int msec = 0, Priority prio = Normal); 00141 00145 virtual ~RTPGroup(); 00146 00150 virtual void cleanup(); 00151 00155 virtual void run(); 00156 00161 static void setMinSleep(int msec); 00162 00167 void join(RTPProcessor* proc); 00168 00173 void part(RTPProcessor* proc); 00174 00175 private: 00176 ObjList m_processors; 00177 bool m_listChanged; 00178 unsigned long m_sleep; 00179 }; 00180 00185 class YRTP_API RTPTransport : public RTPProcessor 00186 { 00187 public: 00191 enum Activation { 00192 Inactive, 00193 Bound, 00194 Active 00195 }; 00196 00200 enum Type { 00201 Unknown, 00202 RTP, 00203 UDPTL 00204 }; 00205 00210 RTPTransport(Type type = RTP); 00211 00215 virtual ~RTPTransport(); 00216 00221 void setProcessor(RTPProcessor* processor = 0); 00222 00227 void setMonitor(RTPProcessor* monitor = 0); 00228 00233 inline const SocketAddr& localAddr() const 00234 { return m_localAddr; } 00235 00240 inline const SocketAddr& remoteAddr() const 00241 { return m_remoteAddr; } 00242 00249 bool localAddr(SocketAddr& addr, bool rtcp = true); 00250 00257 bool remoteAddr(SocketAddr& addr, bool sniff = false); 00258 00264 inline bool setTOS(int tos) 00265 { return m_rtpSock.setTOS(tos); } 00266 00271 inline Socket* rtpSock() 00272 { return &m_rtpSock; } 00273 00278 bool drillHole(); 00279 00280 protected: 00285 virtual void timerTick(const Time& when); 00286 00292 virtual void rtpData(const void* data, int len); 00293 00299 virtual void rtcpData(const void* data, int len); 00300 00301 private: 00302 Type m_type; 00303 RTPProcessor* m_processor; 00304 RTPProcessor* m_monitor; 00305 Socket m_rtpSock; 00306 Socket m_rtcpSock; 00307 SocketAddr m_localAddr; 00308 SocketAddr m_remoteAddr; 00309 SocketAddr m_remoteRTCP; 00310 bool m_autoRemote; 00311 }; 00312 00319 class YRTP_API RTPDejitter : public RTPProcessor 00320 { 00321 public: 00328 RTPDejitter(RTPReceiver* receiver, unsigned int mindelay, unsigned int maxdelay); 00329 00333 virtual ~RTPDejitter(); 00334 00343 virtual bool rtpRecvData(bool marker, unsigned int timestamp, 00344 const void* data, int len); 00345 00346 protected: 00351 virtual void timerTick(const Time& when); 00352 00353 private: 00354 ObjList m_packets; 00355 RTPReceiver* m_receiver; 00356 unsigned int m_mindelay; 00357 unsigned int m_maxdelay; 00358 unsigned int m_headStamp; 00359 unsigned int m_tailStamp; 00360 u_int64_t m_headTime; 00361 u_int64_t m_tailTime; 00362 }; 00363 00368 class YRTP_API RTPBaseIO 00369 { 00370 friend class RTPSession; 00371 friend class RTPSecure; 00372 public: 00376 inline RTPBaseIO(RTPSession* session = 0) 00377 : m_session(session), m_secure(0), 00378 m_ssrcInit(true), m_ssrc(0), m_ts(0), 00379 m_seq(0), m_rollover(0), m_secLen(0), m_mkiLen(0), 00380 m_evTs(0), m_evNum(-1), m_evVol(-1), 00381 m_ioPackets(), m_ioOctets(0), 00382 m_dataType(-1), m_eventType(-1), m_silenceType(-1) 00383 { } 00384 00388 virtual ~RTPBaseIO(); 00389 00394 inline int dataPayload() const 00395 { return m_dataType; } 00396 00402 bool dataPayload(int type); 00403 00408 inline int eventPayload() const 00409 { return m_eventType; } 00410 00416 bool eventPayload(int type); 00417 00422 inline int silencePayload() const 00423 { return m_silenceType; } 00424 00431 bool silencePayload(int type); 00432 00437 unsigned int ssrcInit(); 00438 00442 inline void reset() 00443 { m_ssrcInit = true; } 00444 00449 inline unsigned int ssrc() const 00450 { return m_ssrcInit ? 0 : m_ssrc; } 00451 00455 inline void ssrc(unsigned int src) 00456 { m_ssrc = src; m_ssrcInit = false; } 00457 00462 inline u_int16_t seq() const 00463 { return m_seq; } 00464 00469 inline u_int32_t rollover() const 00470 { return m_rollover; } 00471 00476 inline u_int64_t fullSeq() const 00477 { return m_seq | (((u_int64_t)m_rollover) << 16); } 00478 00483 inline u_int32_t ioPackets() const 00484 { return m_ioPackets; } 00485 00490 inline u_int32_t ioOctets() const 00491 { return m_ioOctets; } 00492 00497 inline RTPSession* session() const 00498 { return m_session; } 00499 00504 inline RTPSecure* security() const 00505 { return m_secure; } 00506 00511 void security(RTPSecure* secure); 00512 00513 protected: 00518 virtual void timerTick(const Time& when) = 0; 00519 00525 inline void secLength(u_int32_t len, u_int32_t key = 0) 00526 { m_secLen = len; m_mkiLen = key; } 00527 00528 RTPSession* m_session; 00529 RTPSecure* m_secure; 00530 bool m_ssrcInit; 00531 u_int32_t m_ssrc; 00532 u_int32_t m_ts; 00533 u_int16_t m_seq; 00534 u_int32_t m_rollover; 00535 u_int16_t m_secLen; 00536 u_int16_t m_mkiLen; 00537 u_int32_t m_evTs; 00538 int m_evNum; 00539 int m_evVol; 00540 u_int32_t m_ioPackets; 00541 u_int32_t m_ioOctets; 00542 00543 private: 00544 int m_dataType; 00545 int m_eventType; 00546 int m_silenceType; 00547 }; 00548 00553 class YRTP_API RTPReceiver : public RTPBaseIO 00554 { 00555 friend class RTPSession; 00556 public: 00560 inline RTPReceiver(RTPSession* session = 0) 00561 : RTPBaseIO(session), 00562 m_ioLostPkt(0), m_dejitter(0), m_tsLast(0), 00563 m_seqSync(0), m_seqCount(0), m_warn(true) 00564 { } 00565 00569 virtual ~RTPReceiver(); 00570 00575 inline u_int32_t ioPacketsLost() const 00576 { return m_ioLostPkt; } 00577 00578 00583 void setDejitter(RTPDejitter* dejitter); 00584 00590 inline void setDejitter(unsigned int mindelay, unsigned int maxdelay) 00591 { setDejitter(new RTPDejitter(this,mindelay,maxdelay)); } 00592 00603 virtual bool rtpRecv(bool marker, int payload, unsigned int timestamp, 00604 const void* data, int len); 00605 00614 virtual bool rtpRecvData(bool marker, unsigned int timestamp, 00615 const void* data, int len); 00616 00626 virtual bool rtpRecvEvent(int event, char key, int duration, 00627 int volume, unsigned int timestamp); 00628 00636 virtual void rtpNewPayload(int payload, unsigned int timestamp); 00637 00645 virtual void rtpNewSSRC(u_int32_t newSsrc, bool marker); 00646 00647 protected: 00652 virtual void timerTick(const Time& when); 00653 00664 virtual bool rtpDecipher(unsigned char* data, int len, const void* secData, u_int32_t ssrc, u_int64_t seq); 00665 00676 virtual bool rtpCheckIntegrity(const unsigned char* data, int len, const void* authData, u_int32_t ssrc, u_int64_t seq); 00677 00678 u_int32_t m_ioLostPkt; 00679 00680 private: 00681 void rtpData(const void* data, int len); 00682 void rtcpData(const void* data, int len); 00683 bool decodeEvent(bool marker, unsigned int timestamp, const void* data, int len); 00684 bool decodeSilence(bool marker, unsigned int timestamp, const void* data, int len); 00685 void finishEvent(unsigned int timestamp); 00686 bool pushEvent(int event, int duration, int volume, unsigned int timestamp); 00687 RTPDejitter* m_dejitter; 00688 unsigned int m_tsLast; 00689 u_int16_t m_seqSync; 00690 u_int16_t m_seqCount; 00691 bool m_warn; 00692 }; 00693 00698 class YRTP_API RTPSender : public RTPBaseIO 00699 { 00700 public: 00706 RTPSender(RTPSession* session = 0, bool randomTs = true); 00707 00711 virtual ~RTPSender() 00712 { } 00713 00723 bool rtpSend(bool marker, int payload, unsigned int timestamp, 00724 const void* data, int len); 00725 00734 bool rtpSendData(bool marker, unsigned int timestamp, 00735 const void* data, int len); 00736 00745 bool rtpSendEvent(int event, int duration, int volume = 0, unsigned int timestamp = 0); 00746 00755 bool rtpSendKey(char key, int duration, int volume = 0, unsigned int timestamp = 0); 00756 00757 00762 inline int padding() const 00763 { return m_padding; } 00764 00770 bool padding(int chunk); 00771 00772 protected: 00777 virtual void timerTick(const Time& when); 00778 00785 virtual void rtpEncipher(unsigned char* data, int len); 00786 00794 virtual void rtpAddIntegrity(const unsigned char* data, int len, unsigned char* authData); 00795 00796 00797 private: 00798 int m_evTime; 00799 unsigned int m_tsLast; 00800 unsigned char m_padding; 00801 bool sendEventData(unsigned int timestamp); 00802 }; 00803 00808 class YRTP_API UDPSession : public RTPProcessor 00809 { 00810 public: 00814 virtual ~UDPSession(); 00815 00821 virtual RTPTransport* createTransport(); 00822 00827 bool initTransport(); 00828 00835 bool initGroup(int msec = 0, Thread::Priority prio = Thread::Normal); 00836 00843 inline bool remoteAddr(SocketAddr& addr, bool sniff = false) 00844 { return m_transport && m_transport->remoteAddr(addr,sniff); } 00845 00851 inline bool setTOS(int tos) 00852 { return m_transport && m_transport->setTOS(tos); } 00853 00858 inline Socket* rtpSock() 00859 { return m_transport ? m_transport->rtpSock() : 0; } 00860 00865 inline bool drillHole() 00866 { return m_transport && m_transport->drillHole(); } 00867 00872 void setTimeout(int interval); 00873 00878 inline RTPTransport* transport() const 00879 { return m_transport; } 00880 00885 virtual void transport(RTPTransport* trans); 00886 00887 protected: 00891 UDPSession(); 00892 00897 virtual void timeout(bool initial); 00898 00899 RTPTransport* m_transport; 00900 u_int64_t m_timeoutTime; 00901 u_int64_t m_timeoutInterval; 00902 }; 00903 00908 class YRTP_API RTPSession : public UDPSession 00909 { 00910 public: 00914 enum Direction { 00915 FullStop = 0, 00916 RecvOnly = 1, 00917 SendOnly = 2, 00918 SendRecv = 3 00919 }; 00920 00924 RTPSession(); 00925 00929 virtual ~RTPSession(); 00930 00935 virtual void getStats(String& stats) const; 00936 00942 virtual void rtpData(const void* data, int len); 00943 00949 virtual void rtcpData(const void* data, int len); 00950 00959 virtual bool rtpRecvData(bool marker, unsigned int timestamp, 00960 const void* data, int len); 00961 00971 virtual bool rtpRecvEvent(int event, char key, int duration, 00972 int volume, unsigned int timestamp); 00973 00981 virtual void rtpNewPayload(int payload, unsigned int timestamp); 00982 00990 virtual void rtpNewSSRC(u_int32_t newSsrc, bool marker); 00991 00997 virtual RTPSender* createSender(); 00998 01004 virtual RTPReceiver* createReceiver(); 01005 01012 virtual Cipher* createCipher(const String& name, Cipher::Direction dir); 01013 01019 virtual bool checkCipher(const String& name); 01020 01030 inline bool rtpSend(bool marker, int payload, unsigned int timestamp, 01031 const void* data, int len) 01032 { return m_send && m_send->rtpSend(marker,payload,timestamp,data,len); } 01033 01042 inline bool rtpSendData(bool marker, unsigned int timestamp, 01043 const void* data, int len) 01044 { return m_send && m_send->rtpSendData(marker,timestamp,data,len); } 01045 01054 inline bool rtpSendEvent(int event, int duration, int volume = 0, unsigned int timestamp = 0) 01055 { return m_send && m_send->rtpSendEvent(event,duration,volume,timestamp); } 01056 01065 inline bool rtpSendKey(char key, int duration, int volume = 0, unsigned int timestamp = 0) 01066 { return m_send && m_send->rtpSendKey(key,duration,volume,timestamp); } 01067 01072 inline int padding() const 01073 { return m_send ? m_send->padding() : 0; } 01074 01080 inline bool padding(int chunk) 01081 { return m_send && m_send->padding(chunk); } 01082 01088 inline void setDejitter(unsigned int mindelay = 20, unsigned int maxdelay = 50) 01089 { if (m_recv) m_recv->setDejitter(mindelay,maxdelay); } 01090 01095 virtual void transport(RTPTransport* trans); 01096 01101 inline RTPSender* sender() const 01102 { return m_send; } 01103 01108 void sender(RTPSender* send); 01109 01114 inline RTPReceiver* receiver() const 01115 { return m_recv; } 01116 01121 void receiver(RTPReceiver* recv); 01122 01127 inline Direction direction() const 01128 { return m_direction; } 01129 01136 bool direction(Direction dir); 01137 01144 inline bool addDirection(Direction dir) 01145 { return direction((Direction)(m_direction | dir)); } 01146 01153 inline bool delDirection(Direction dir) 01154 { return direction((Direction)(m_direction & ~dir)); } 01155 01161 bool dataPayload(int type); 01162 01168 bool eventPayload(int type); 01169 01175 bool silencePayload(int type); 01176 01183 inline bool localAddr(SocketAddr& addr, bool rtcp = true) 01184 { return m_transport && m_transport->localAddr(addr,rtcp); } 01185 01190 inline RTPSecure* security() const 01191 { return m_send ? m_send->security() : m_secure; } 01192 01197 void security(RTPSecure* secure); 01198 01199 protected: 01204 virtual void timerTick(const Time& when); 01205 01206 private: 01207 Direction m_direction; 01208 RTPSender* m_send; 01209 RTPReceiver* m_recv; 01210 RTPSecure* m_secure; 01211 }; 01212 01217 class YRTP_API UDPTLSession : public UDPSession 01218 { 01219 public: 01223 ~UDPTLSession(); 01224 01230 inline bool localAddr(SocketAddr& addr) 01231 { return m_transport && m_transport->localAddr(addr,false); } 01232 01237 inline u_int16_t maxLen() const 01238 { return m_maxLen; } 01239 01244 inline u_int8_t maxSec() const 01245 { return m_maxSec; } 01246 01252 virtual void rtpData(const void* data, int len); 01253 01261 bool udptlSend(const void* data, int len, u_int16_t seq); 01262 01263 protected: 01269 UDPTLSession(u_int16_t maxLen = 250, u_int8_t maxSec = 2); 01270 01275 virtual void timerTick(const Time& when); 01276 01282 virtual RTPTransport* createTransport(); 01283 01291 virtual void udptlRecv(const void* data, int len, u_int16_t seq, bool recovered) = 0; 01292 01293 private: 01294 void recoverSec(const unsigned char* data, int len, u_int16_t seq, int nSec); 01295 u_int16_t m_rxSeq; 01296 u_int16_t m_txSeq; 01297 u_int16_t m_maxLen; 01298 u_int8_t m_maxSec; 01299 bool m_warn; 01300 ObjList m_txQueue; 01301 }; 01302 01307 class YRTP_API RTPSecure : public GenObject 01308 { 01309 friend class RTPReceiver; 01310 friend class RTPSender; 01311 friend class RTPSession; 01312 public: 01316 RTPSecure(); 01317 01322 RTPSecure(const String& suite); 01323 01328 RTPSecure(const RTPSecure& other); 01329 01333 virtual ~RTPSecure(); 01334 01339 inline RTPBaseIO* owner() const 01340 { return m_owner; } 01341 01346 void owner(RTPBaseIO* newOwner); 01347 01352 inline Cipher* rtpCipher() const 01353 { return m_rtpCipher; } 01354 01360 virtual bool supported(RTPSession* session = 0) const; 01361 01369 virtual bool setup(const String& suite, const String& keyParams, const ObjList* paramList = 0); 01370 01378 virtual bool create(String& suite, String& keyParams, bool buildMaster = true); 01379 01380 protected: 01384 virtual void init(); 01385 01391 virtual void rtpEncipher(unsigned char* data, int len); 01392 01399 virtual void rtpAddIntegrity(const unsigned char* data, int len, unsigned char* authData); 01400 01410 virtual bool rtpDecipher(unsigned char* data, int len, const void* secData, u_int32_t ssrc, u_int64_t seq); 01411 01421 virtual bool rtpCheckIntegrity(const unsigned char* data, int len, const void* authData, u_int32_t ssrc, u_int64_t seq); 01422 01432 bool deriveKey(Cipher& cipher, DataBlock& key, unsigned int len, unsigned char label, u_int64_t index = 0); 01433 01434 private: 01435 RTPBaseIO* m_owner; 01436 Cipher* m_rtpCipher; 01437 DataBlock m_masterKey; 01438 DataBlock m_masterSalt; 01439 DataBlock m_cipherKey; 01440 DataBlock m_cipherSalt; 01441 SHA1 m_authIpad; 01442 SHA1 m_authOpad; 01443 u_int32_t m_rtpAuthLen; 01444 bool m_rtpEncrypted; 01445 }; 01446 01447 } 01448 01449 #endif /* __YATERTP_H */ 01450 01451 /* vi: set ts=8 sw=4 sts=4 noet: */