ZrtpQueue.h

Go to the documentation of this file.

/*
  Copyright (C) 2006-2009 Werner Dittmann

  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 3 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, see <http://www.gnu.org/licenses/>.
*/

#ifndef _ZRTPQUEUE_H_
#define _ZRTPQUEUE_H_

#include <ccrtp/cqueue.h>
#include <ccrtp/rtppkt.h>
#include <libzrtpcpp/ZrtpCallback.h>
#include <libzrtpcpp/TimeoutProvider.h>
#include <libzrtpcpp/ZrtpConfigure.h>

class __EXPORT ZrtpUserCallback;
class __EXPORT ZRtp;

NAMESPACE_COMMONCPP

class __EXPORT ZrtpQueue : public AVPQueue, ZrtpCallback {

public:

    int32_t initialize(const char *zidFilename, bool autoEnable = true,
                       ZrtpConfigure* config = NULL);

    /*
     * Applications use the following methods to control ZRTP, for example
     * to enable ZRTP, set flags etc.
     */

    void setEnableZrtp(bool onOff);

    bool isEnableZrtp();

    void SASVerified();

    void resetSASVerified();

    void goClearOk();

    void requestGoClear();

    void setAuxSecret(uint8_t* data, int32_t length);

    void setUserCallback(ZrtpUserCallback* ucb);

    void setClientId(std::string id);

    std::string getHelloHash();

    std::string getPeerHelloHash();

    std::string getMultiStrParams();

    void setMultiStrParams(std::string parameters);

    bool isMultiStream();

    bool isMultiStreamAvailable();

    void acceptEnrollment(bool accepted);

    std::string getSasType();

    uint8_t* getSasHash();

    bool sendSASRelayPacket(uint8_t* sh, std::string render);

    bool isMitmMode();

    void setMitmMode(bool mitmMode);

    void setParanoidMode(bool yesNo);

    bool isParanoidMode();

    bool isEnrollmentMode();

    void setEnrollmentMode(bool enrollmentMode);

    inline void setPBXEnrollment(bool enrollmentMode)
        {setMitmMode(enrollmentMode); setEnrollmentMode(enrollmentMode);}

    bool isPeerEnrolled();

    void setSignSas(bool sasSignMode);

    bool setSignatureData(uint8* data, int32 length);

    const uint8* getSignatureData();

    int32 getSignatureLength();

    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 startZrtp();

    void stopZrtp();

    int32 getPeerZid(uint8* data);

protected:
    friend class TimeoutProvider<std::string, ost::ZrtpQueue*>;

    virtual bool
    onSRTPPacketError(IncomingRTPPkt& pkt, int32 errorCode);

    void handleTimeout(const std::string &c);

    virtual size_t takeInDataPacket();

    /*
     * The following methods implement the GNU ZRTP callback interface.
     * For detailed documentation refer to file ZrtpCallback.h
     */
    int32_t sendDataZRTP(const unsigned char* data, int32_t length);

    int32_t activateTimer(int32_t time);

    int32_t cancelTimer();

    void sendInfo(GnuZrtpCodes::MessageSeverity severity, int32_t subCode);

    bool srtpSecretsReady(SrtpSecret_t* secrets, EnableSecurity part);

    void srtpSecretsOff(EnableSecurity part);

    void srtpSecretsOn(std::string c, std::string s, bool verified);

    void handleGoClear();

    void zrtpNegotiationFailed(GnuZrtpCodes::MessageSeverity severity, int32_t subCode);

    void zrtpNotSuppOther();

    void synchEnter();

    void synchLeave();

    void zrtpAskEnrollment(GnuZrtpCodes::InfoEnrollment info);

    void zrtpInformEnrollment(GnuZrtpCodes::InfoEnrollment  info);

    void signSAS(uint8_t* sasHash);

    bool checkSASSignature(uint8_t* sasHash);

    /*
     * End of ZrtpCallback functions.
     */

    ZrtpQueue(uint32 size = RTPDataQueue::defaultMembersHashSize,
              RTPApplication& app = defaultApplication());

    ZrtpQueue(uint32 ssrc, uint32 size =
                  RTPDataQueue::defaultMembersHashSize,
              RTPApplication& app = defaultApplication());

    virtual ~ZrtpQueue();

private:
    void init();
    size_t rtpDataPacket(unsigned char* packet, int32 rtn,
                         InetHostAddress network_address,
                         tpport_t transport_port);

    ZRtp *zrtpEngine;
    ZrtpUserCallback* zrtpUserCallback;

    std::string clientIdString;

    bool enableZrtp;

    int32 secureParts;

    int16 senderZrtpSeqNo;
    ost::Mutex synchLock;   // Mutex for ZRTP (used by ZrtpStateClass)
    uint32 peerSSRC;
    bool started;
    bool mitmMode;
    bool signSas;
    bool enableParanoidMode;
};

class IncomingZRTPPkt : public IncomingRTPPkt {

public:
    IncomingZRTPPkt(const unsigned char* block, size_t len);

    ~IncomingZRTPPkt()
    { }

    uint32
    getZrtpMagic() const;

    uint32
    getSSRC() const;
};

class OutgoingZRTPPkt : public OutgoingRTPPkt {

public:
    OutgoingZRTPPkt(const unsigned char* const hdrext, uint32 hdrextlen);
    ~OutgoingZRTPPkt()
    { }
};

END_NAMESPACE

#endif