SdpBody.h

Go to the documentation of this file.

//
// Copyright (C) 2005-2013 SIPez LLC.  All rights reserved.
// 
// Copyright (C) 2004 SIPfoundry Inc.
// Licensed by SIPfoundry under the LGPL license.
//
// Copyright (C) 2004-2006 Pingtel Corp.  All rights reserved.
// Licensed to SIPfoundry under a Contributor Agreement.
//
// $$
// Author: Daniel Petrie (dpetrie AT SIPez DOT com)

#ifndef _SdpBody_h_
#define _SdpBody_h_

// SYSTEM INCLUDES
// APPLICATION INCLUDES
#include <utl/UtlDefs.h>
#include <utl/UtlSListIterator.h>
#include <os/OsSocket.h>
#include <os/OsNatConnectionSocket.h>
#include <tapi/sipXtapiEvents.h>
#include <sdp/SdpMediaLine.h>
#include <net/HttpBody.h>
#include <net/NameValuePair.h>
#include <sdp/SdpCodec.h>

// DEFINES
#define SDP_AUDIO_MEDIA_TYPE "audio"
#define SDP_VIDEO_MEDIA_TYPE "video"
#define SDP_APPLICATION_MEDIA_TYPE "application"

// Crypto suites
#define AES_CM_128_HMAC_SHA1_80   1
#define AES_CM_128_HMAC_SHA1_32   2
#define F8_128_HMAC_SHA1_80       3
// Protection level
#define SRTP_ENCRYPTION           0x0001
#define SRTP_AUTHENTICATION       0x0002
#define SRTP_SEND                 0x0004
#define SRTP_RECEIVE              0x0008
#define SRTP_OFF                  0
#define SRTP_ON                   (SRTP_ENCRYPTION|SRTP_AUTHENTICATION|SRTP_SEND|SRTP_RECEIVE)
#define SRTP_SECURITY_MASK        (SRTP_ENCRYPTION|SRTP_AUTHENTICATION)
// Key length       
#define SRTP_KEY_LENGTH          30

// MACROS
// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS
#define SDP_CONTENT_TYPE "application/sdp"
// STRUCTS
// TYPEDEFS
typedef struct SdpSrtpParameters
{
    int cipherType;
    int securityLevel;
    unsigned char masterKey[SRTP_KEY_LENGTH+1];
} SdpSrtpParameters;


// FORWARD DECLARATIONS
class SdpCodecList;
class SdpMediaLine;


class SdpBody : public HttpBody
{
/* //////////////////////////// PUBLIC //////////////////////////////////// */
  public:

   typedef enum 
   {
      Unknown,
      Inactive,
      SendOnly,
      RecvOnly,
      SendRecv
   } SessionDirection;

   SdpBody(const char* bytes = NULL, 
           int byteCount = -1        
           );

   SdpBody(const SdpBody& rSdpBody);

   virtual
      ~SdpBody();

   
   virtual int getLength() const;

   virtual void getBytes(const char** bytes, 
                         int* length         
                         ) const;

   virtual void getBytes(UtlString* bytes, 
                         int* length       
                         ) const;


   void setStandardHeaderFields(const char* sessionName,  
                                const char* emailAddress, 
                                const char* phoneNumber,  
                                const char* originatorAddress 
                                );


   void setSessionNameField(const char* sessionName);

   void setOriginator(const char* userId,
                      int sessionId,     
                      int sessionVersion,
                      const char* address
                      );

   void setEmailAddressField(const char* emailAddress);

   void setPhoneNumberField(const char* phoneNumber);

   // Append a 't' field after any existing times, converting from epoch->ntp time.
   void addEpochTime(unsigned long epochStartTime,
                     unsigned long epochEndTime = 0
                     );

   // Append a 't' field after any existing times.
   void addNtpTime(unsigned long ntpStartTime,
                   unsigned long ntpEndTime = 0
                   );

   // Get the stream direction or activity state (i.e. sendrecv, sendonly, recvonly, inactive)
   UtlBoolean getMediaStreamDirection(int mediaIndex, 
                                      SessionDirection& direction) const;

   // set all media attributes to either a=setup:actpass, a=setup:active, or a=setup:passive
   void setRtpTcpRole(RtpTcpRoles role);                   
   UtlString getRtpTcpRole() const;


   void addCodecsOffer(int iNumAddresses,
                       const UtlString mediaAddresses[],
                       int rtpAudioPorts[],
                       int rtcpAudioPorts[],
                       int rtpVideoPorts[],
                       int rtcpVideoPorts[],
                       RTP_TRANSPORT transportTypes[],
                       int numRtpCodecs,
                       SdpCodec* rtpCodecs[],
                       SdpSrtpParameters& srtpParams,
                       int videoBandwidth,
                       int videoFramerate,
                       RTP_TRANSPORT transportOffering
                       );

   // Build a MediaLine (for local capabilities for using in addMediaLinesAnswer)
   static void buildMediaLine(SdpMediaLine::SdpMediaType mediaType,
                              int totalBandwidth,
                              int iNumAddresses,
                              UtlString hostAddresses[],
                              int rtpPorts[],
                              int rtcpPorts[],
                              int numRtpCodecs,
                              SdpCodec* rtpCodecs[],
                              SdpMediaLine& mediaLine);

   void addCodecsAnswer(int iNumAddresses,
                       UtlString mediaAddresses[],
                       int rtpAudioPorts[],
                       int rtcpAudioPorts[],
                       int rtpVideoPorts[],
                       int rtcpVideoPorts[],
                       RTP_TRANSPORT transportTypes[],
                       int numRtpCodecs, 
                       SdpCodec* rtpCodecs[],
                       SdpSrtpParameters& srtpParams,
                       int videoBandwidth,
                       int videoFramerate,
                       const SdpBody* sdpRequest  
                       ); 
   // Create an answer SDP in this for the given media streams and SDP offer
   void addMediaLinesAnswer(int numMediaLines, const SdpMediaLine* mediaLines[], const SdpBody& offer);

   void addMediaData(const char* mediaType, 
                     int portNumber,        
                     int portPairCount,     
                     const char* mediaTransportType, 
                     int numPayloadTypes,   
                     int payloadType[]      
                     );

   void addCodecParameters(int numRtpCodecs,
                           SdpCodec* rtpCodecs[],
                           const char* szMimeType = "audio"
                           );

   void addConnectionAddress(const char* ipAddress 
                       );
   void addConnectionAddress(const char* networkType, 
                       const char* addressType, 
                       const char* ipAddress    
                       );

   void setConnectionAddress(const char* ipAddress 
                       );
   void setConnectionAddress(const char* networkType, 
                       const char* addressType, 
                       const char* ipAddress    
                       );

   void addRtpmap(int payloadType,
                  const char* mimeSubtype,
                  int sampleRate,
                  int numChannels
                  );

   void addSrtpCryptoField(SdpSrtpParameters& params);

   void addFormatParameters(int payloadType,
                            const char* formatParameters
                            );

   void addPtime(int pTime);

    void addCandidateAttribute(int         candidateId, 
                               const char* transportId, 
                               const char* transportType,
                               uint64_t    qValue, 
                               const char* candidateIp, 
                               int         candidatePort) ;

   
   int getMediaSetCount() const;

   int findMediaType(const char* mediaType,  
                     int startMediaIndex = 0 
                     ) const;
   UtlBoolean getMediaData(int mediaIndex, 
                           UtlString* mediaType,
                           int* mediaPort,
                           int* mediaPortPairs,
                           UtlString* mediaTransportType,
                           int maxPayloadTypes,
                           int* numPayloadTypes,
                           int payloadTypes[]) const;

   const bool isTransportAvailable(const OsSocket::IpProtocolSocketType protocol,
                                   const SIPX_MEDIA_TYPE mediaType) const;
                                   
   UtlBoolean getMediaNetworkType(int mediaIndex, 
                                  UtlString* networkType) const;

   UtlBoolean getMediaAddress(int mediaIndex, 
                              UtlString* address) const;

   UtlBoolean getMediaType(int mediaIndex, 
                           UtlString* mediaType 
                           ) const;

   UtlBoolean getMediaPort(int mediaIndex, 
                           int* port) const;

   // Get the rtcp port number of the indicated media stream.
   UtlBoolean getMediaRtcpPort(int mediaIndex, 
                               int* port) const ;

   UtlBoolean getMediaPortCount(int mediaIndex, 
                                int* numPorts) const;
   UtlBoolean getMediaProtocol(int mediaIndex, 
                               UtlString* transportProtocol
                               ) const;

   UtlBoolean getMediaPayloadType(int mediaIndex, 
                                  int maxTypes,   
                                  int* numTypes,  
                                  int payloadTypes[] 
                                  ) const;

   UtlBoolean getPtime(int mediaIndex, int& ptime) const;

   UtlBoolean getMediaSubfield(int mediaIndex,
                               int subfieldIndex,
                               UtlString* subField
                               ) const;

   UtlBoolean getPayloadRtpMap(int mediaIndex,         
                               int payloadType,        
                               UtlString& mimeSubtype, 
                               int& sampleRate,        
                               int& numChannels        
                               ) const;

   // Get the fmtp parameter
   UtlBoolean getPayloadFormat(int mediaIndex,         
                               int payloadType,
                               UtlString& fmtp) const;
   // Get the crypto field for SRTP
   UtlBoolean getSrtpCryptoField(int mediaIndex,                  
                                 int index,                       
                                 SdpSrtpParameters& params) const;

   // Get the a=control;trackId= value
   UtlBoolean getControlTrackId(int mediaLineIndex, UtlString& trackId) const;

   // Get the framerate field if there
   UtlBoolean getFramerateField(int mediaIndex,
                                int& videoFramerate) const;

   UtlBoolean getBandwidthField(int& bandwidth) const;

#if 0
   void getBestAudioCodecs(int numRtpCodecs,
                           SdpCodec rtpCodecs[],
                           UtlString* rtpAddress,
                           int* rtpPort,
                           int* sendCodecIndex,
                           int* receiveCodecIndex) const;
#endif


   void getBestAudioCodecs(SdpCodecList& localRtpCodecs,
                           int& numCodecsInCommon,
                           SdpCodec**& commonCodecsForEncoder,
                           //SdpCodec**& commonCodecsForDecoder,
                           UtlString& rtpAddress, 
                           int& rtpPort,
                           int& rtcpPort,
                           int& videoRtpPort,
                           int& videoRtcpPort,
                           SdpSrtpParameters& localSrtpParams,
                           SdpSrtpParameters& matchingSrtpParams,
                           int localBandwidth,
                           int& matchingBandwidth,
                           int localVideoFramerate,
                           int& matchingVideoFramerate) const;
             
   // TODO: This interface is total broken and needs to be eliminated
   // It munges the codecs and payload types accross all of the m lines
   void getCodecsInCommon(int audioMediaSetIndex,
                          int videoMediaSetIndex,
                          int audioPayloadIdCount,
                          int videoPayloadIdCount,
                          int audioPayloadTypes[],
                          int videoPayloadTypes[],
                          int videoRtpPort,
                          SdpCodecList& localRtpCodecs,
                          int& numCodecsInCommon,
                          SdpCodec* commonCodecsForEncoder[],
                          SdpCodec* commonCodecsForDecoder[]) const;

   int getCodecsInCommon(const SdpMediaLine& localMediaLine,
                         int remoteMediaLineIndex,
                         SdpMediaLine& remoteMediaLine,
                         SdpCodecList& localDecodeCodecs) const;
   // Reads the indexed m line from this SDP into the given SdpMediaLine container.
   UtlBoolean getMediaLine(int remoteMediaLineIndex, SdpMediaLine& mediaLine, const SdpCodecList* codecFactory) const;

   // Add a SdpMediaLine object to this SdpBody
   void addMediaLine(const SdpMediaLine& mediaLine, SdpBody& sdpBody);

   // Find common encryption suites
   void getEncryptionInCommon(SdpSrtpParameters& audioParams,
                              SdpSrtpParameters& remoteParams,
                              SdpSrtpParameters& commonAudioParms) const;

   // Find common bandwidth
   void getBandwidthInCommon(int localBandwidth,
                             int remoteBandwidth,
                             int& commonBandwidth) const;

   // Find a common video framerate
   void getVideoFramerateInCommon(int localVideoFramerate,
                                  int remoteVideoFramerate,
                                  int& commonVideoFramerate) const;

    UtlBoolean getCandidateAttribute(int mediaIndex,
                                     int candidateIndex,
                                     int& rCandidateId,
                                     UtlString& rTransportId,
                                     UtlString& rTransportType,
                                     uint64_t& rQvalue, 
                                     UtlString& rCandidateIp, 
                                     int& rCandidatePort) const ;


   UtlBoolean getCandidateAttributes(const char* szMimeType,
                                     int         nMaxAddresses,                                     
                                     int         candidateIds[],
                                     UtlString   transportIds[],
                                     UtlString   transportTypes[],
                                     uint64_t    qvalues[], 
                                     UtlString   candidateIps[], 
                                     int         candidatePorts[],
                                     int&        nActualAddresses) const ;

   UtlBoolean getCandidateAttributes(int         mediaIndex,
                                     int         nMaxAddresses,                                     
                                     int         candidateIds[],
                                     UtlString   transportIds[],
                                     UtlString   transportTypes[],
                                     uint64_t    qvalues[], 
                                     UtlString   candidateIps[], 
                                     int         candidatePorts[],
                                     int&        nActualAddresses) const ;

   UtlBoolean findValueInField(const char* pField, const char* pvalue) const;



/* //////////////////////////// PROTECTED ///////////////////////////////// */
  protected:
   friend class SdpBodyTest;
   
   int getFieldCount() const;

   UtlBoolean getValue(int fieldIndex,
                       UtlString* name,
                       UtlString* value) const;
   void setValue(const char* name,       
                 const char* value       
                 );


   void parseBody(const char* bytes = NULL, 
                  int byteCount = -1        
                  );


/* //////////////////////////// PRIVATE /////////////////////////////////// */
  private:

   size_t findFirstOf( const char* headers );
   bool isOptionalField(const char* name) const;

   void addValue(const char* name, 
                 const char* value = NULL, 
                 int fieldIndex = -1       
                 );
   
   UtlSList* sdpFields;

   static NameValuePair* positionFieldInstance(int fieldInstanceIndex, 
                                               UtlSListIterator* iter, 
                                               const char* fieldName
                                               );
   static NameValuePair* findFieldNameBefore(UtlSListIterator* iter,
                                             const char* targetFieldName,
                                             const char* beforeFieldName);

   SdpBody& operator=(const SdpBody& rhs);

};

/* ============================ INLINE METHODS ============================ */

#endif  // _SdpBody_h_