oqueue.h

Go to the documentation of this file.

// Copyright (C) 2001,2002,2004,2005 Federico Montesino Pouzols <fedemp@altern.org>.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// This exception applies only to the code released under the name GNU
// ccRTP.  If you copy code from other releases into a copy of GNU
// ccRTP, as the General Public License permits, the exception does
// not apply to the code that you add in this way.  To avoid misleading
// anyone as to the status of such modified files, you must delete
// this exception notice from them.
//
// If you write modifications of your own for GNU ccRTP, it is your choice
// whether to permit this exception to apply to your modifications.
// If you do not wish that, delete this exception notice.
//

#ifndef CCXX_RTP_OQUEUE_H_
#define CCXX_RTP_OQUEUE_H_

#include <ccrtp/queuebase.h>
#include <ccrtp/CryptoContext.h>
#include <list>

#ifdef  CCXX_NAMESPACES
namespace ost {
#endif

class __EXPORT DestinationListHandler
{
protected:
        struct TransportAddress;
        std::list<TransportAddress*> destList;

public:
        DestinationListHandler();

        ~DestinationListHandler();

        inline bool isSingleDestination() const
        { return (1 == destList.size()); }

        inline TransportAddress* getFirstDestination() const
        { return destList.front(); }

        inline void lockDestinationList() const
        { destinationLock.readLock(); }

        inline void unlockDestinationList() const
        { destinationLock.unlock(); }

protected:
        inline void writeLockDestinationList() const
        { destinationLock.writeLock(); }

        bool
        addDestinationToList(const InetAddress& ia, tpport_t data,
                             tpport_t control);

        bool removeDestinationFromList(const InetAddress& ia,
                                       tpport_t dataPort,
                                       tpport_t controlPort);

        struct TransportAddress
        {
                TransportAddress(InetAddress na, tpport_t dtp, tpport_t ctp) :
                        networkAddress(na), dataTransportPort(dtp),
                        controlTransportPort(ctp)
                {  }

                inline const InetAddress& getNetworkAddress() const
                { return networkAddress; }

                inline tpport_t getDataTransportPort() const
                { return dataTransportPort; }

                inline tpport_t getControlTransportPort() const
                { return controlTransportPort; }

                InetAddress networkAddress;
                tpport_t dataTransportPort, controlTransportPort;
        };

private:
        mutable ThreadLock destinationLock;
};

#ifdef  CCXX_IPV6

class __EXPORT DestinationListHandlerIPV6
{
protected:
        struct TransportAddressIPV6;
        std::list<TransportAddressIPV6*> destListIPV6;

public:
        DestinationListHandlerIPV6();

        ~DestinationListHandlerIPV6();

        inline bool isSingleDestinationIPV6() const
        { return (1 == destListIPV6.size()); }

        inline TransportAddressIPV6* getFirstDestinationIPV6() const
        { return destListIPV6.front(); }

        inline void lockDestinationListIPV6() const
        { destinationLock.readLock(); }

        inline void unlockDestinationListIPV6() const
        { destinationLock.unlock(); }

protected:
        inline void writeLockDestinationListIPV6() const
        { destinationLock.writeLock(); }

        bool
        addDestinationToListIPV6(const IPV6Address& ia, tpport_t data,
                             tpport_t control);

        bool removeDestinationFromListIPV6(const IPV6Address& ia,
                                       tpport_t dataPort,
                                       tpport_t controlPort);

        struct TransportAddressIPV6
        {
                TransportAddressIPV6(IPV6Address na, tpport_t dtp, tpport_t ctp) :
                        networkAddress(na), dataTransportPort(dtp),
                        controlTransportPort(ctp)
                {  }

                inline const IPV6Address& getNetworkAddress() const
                { return networkAddress; }

                inline tpport_t getDataTransportPort() const
                { return dataTransportPort; }

                inline tpport_t getControlTransportPort() const
                { return controlTransportPort; }

                IPV6Address networkAddress;
                tpport_t dataTransportPort, controlTransportPort;
        };

private:
        mutable ThreadLock destinationLock;
};

#endif

class __EXPORT OutgoingDataQueue:
        public OutgoingDataQueueBase,
#ifdef  CCXX_IPV6
        protected DestinationListHandlerIPV6,
#endif
        protected DestinationListHandler
{
public:
#ifdef  CCXX_IPV6
        bool
        addDestination(const IPV6Address& ia,
                       tpport_t dataPort = DefaultRTPDataPort,
                       tpport_t controlPort = 0);

        bool
        forgetDestination(const IPV6Address& ia,
                          tpport_t dataPort = DefaultRTPDataPort,
                          tpport_t controlPort = 0);

#endif

        bool
        addDestination(const InetHostAddress& ia,
                       tpport_t dataPort = DefaultRTPDataPort,
                       tpport_t controlPort = 0);

        bool
        addDestination(const InetMcastAddress& ia,
                       tpport_t dataPort = DefaultRTPDataPort,
                       tpport_t controlPort = 0);

        bool
        forgetDestination(const InetHostAddress& ia,
                          tpport_t dataPort = DefaultRTPDataPort,
                          tpport_t controlPort = 0);

        bool
        forgetDestination(const InetMcastAddress& ia,
                          tpport_t dataPort = DefaultRTPDataPort,
                          tpport_t controlPort = 0);

        void
        addContributor(uint32 csrc);

        bool
        removeContributor(uint32 csrc);

        bool
        isSending() const;


        void
        putData(uint32 stamp, const unsigned char* data = NULL, size_t len = 0);

        void
        sendImmediate(uint32 stamp, const unsigned char* data = NULL, size_t len = 0);


        void setPadding(uint8 paddinglen)
        { sendInfo.paddinglen = paddinglen; }

        void setMark(bool mark)
        { sendInfo.marked = mark; }

        inline bool getMark() const
        { return sendInfo.marked; }

        size_t
        setPartial(uint32 timestamp, unsigned char* data, size_t offset, size_t max);

        inline microtimeout_t
        getDefaultSchedulingTimeout() const
        { return defaultSchedulingTimeout; }

        inline void
        setSchedulingTimeout(microtimeout_t to)
        { schedulingTimeout = to; }

        inline microtimeout_t
        getDefaultExpireTimeout() const
        { return defaultExpireTimeout; }

        inline void
        setExpireTimeout(microtimeout_t to)
        { expireTimeout = to; }

        inline microtimeout_t getExpireTimeout() const
        { return expireTimeout; }

        inline uint32
        getSendPacketCount() const
        { return sendInfo.packetCount; }

        inline uint32
        getSendOctetCount() const
        { return sendInfo.octetCount; }

        inline uint16
        getSequenceNumber() const
        { return sendInfo.sendSeq; }

        void
        setOutQueueCryptoContext(CryptoContext* cc);

        void
        removeOutQueueCryptoContext(CryptoContext* cc);

        CryptoContext*
        getOutQueueCryptoContext(uint32 ssrc);


protected:
        OutgoingDataQueue();

        virtual ~OutgoingDataQueue()
        { }

        struct OutgoingRTPPktLink
        {
                OutgoingRTPPktLink(OutgoingRTPPkt* pkt,
                                   OutgoingRTPPktLink* p,
                                   OutgoingRTPPktLink* n) :
                        packet(pkt), prev(p), next(n) { }

                ~OutgoingRTPPktLink() { delete packet; }

                inline OutgoingRTPPkt* getPacket() { return packet; }

                inline void setPacket(OutgoingRTPPkt* pkt) { packet = pkt; }

                inline OutgoingRTPPktLink* getPrev() { return prev; }

                inline void setPrev(OutgoingRTPPktLink* p) { prev = p; }

                inline OutgoingRTPPktLink* getNext() { return next; }

                inline void setNext(OutgoingRTPPktLink* n) { next = n; }

                // the packet this link refers to.
                OutgoingRTPPkt* packet;
                // global outgoing packets queue.
                OutgoingRTPPktLink * prev, * next;
        };

        void
        dispatchImmediate(OutgoingRTPPkt *packet);

        microtimeout_t
        getSchedulingTimeout();

        size_t
        dispatchDataPacket();

        inline void
        setNextSeqNum(uint32 seqNum)
        { sendInfo.sendSeq = seqNum; }

        inline uint32
        getCurrentSeqNum(void)
        { return sendInfo.sendSeq; }

        inline void
        setInitialTimestamp(uint32 ts)
        { initialTimestamp = ts; }

        inline uint32
        getInitialTimestamp()
        { return initialTimestamp; }

        void purgeOutgoingQueue();

        virtual void
        setControlPeer(const InetAddress &host, tpport_t port) {}

#ifdef  CCXX_IPV6
        virtual void
        setControlPeerIPV6(const IPV6Address &host, tpport_t port) {}
#endif

        // The crypto contexts for outgoing SRTP sessions.
        mutable Mutex cryptoMutex;
        std::list<CryptoContext *> cryptoContexts;

private:
        inline virtual void onExpireSend(OutgoingRTPPkt&)
        { }

        virtual void
        setDataPeer(const InetAddress &host, tpport_t port) {}

#ifdef  CCXX_IPV6
        virtual void
        setDataPeerIPV6(const IPV6Address &host, tpport_t port) {}
#endif

        virtual size_t
        sendData(const unsigned char* const buffer, size_t len) {return 0;}

#ifdef  CCXX_IPV6
        virtual size_t
        sendDataIPV6(const unsigned char* const buffer, size_t len) {return 0;}
#endif

        static const microtimeout_t defaultSchedulingTimeout;
        static const microtimeout_t defaultExpireTimeout;
        mutable ThreadLock sendLock;
        // outgoing data packets queue
        OutgoingRTPPktLink* sendFirst, * sendLast;
        uint32 initialTimestamp;
        // transmission scheduling timeout for the service thread
        microtimeout_t schedulingTimeout;
        // how old a packet can reach in the sending queue before deletetion
        microtimeout_t expireTimeout;


        struct {
                // number of packets sent from the beginning
                uint32 packetCount;
                // number of payload octets sent from the beginning
                uint32 octetCount;
                // the sequence number of the next packet to sent
                uint16 sendSeq;
                // contributing sources
                uint32 sendSources[16];
                // how many CSRCs to send.
                uint16 sendCC;
                // pad packets to a paddinglen multiple
                uint8 paddinglen;
                // This flags tells whether to set the bit M in the
                // RTP fixed header of the packet in which the next
                // provided data will be sent.
                bool marked;
                // whether there was not loss.
                bool complete;
                // ramdonly generated offset for the timestamp of sent packets
                uint32 initialTimestamp;
                // elapsed time accumulated through successive overflows of
                // the local timestamp field
                timeval overflowTime;
        } sendInfo;
};
 // oqueue

#ifdef  CCXX_NAMESPACES
}
#endif

#endif  //CCXX_RTP_OQUEUE_H_