sdpparser.cpp

Conferencing code using Dialogic hardware

/**********@@@SOFT@@@WARE@@@COPY@@@RIGHT@@@**********************************
* DIALOGIC CONFIDENTIAL
*
* Copyright (C) 2006-2007 Dialogic Corporation. All Rights Reserved.
* The source code contained or described herein and all documents related
* to the source code ("Material") are owned by Dialogic Corporation or its
* suppliers or licensors. Title to the Material remains with Dialogic Corporation
* or its suppliers and licensors. The Material contains trade secrets and
* proprietary and confidential information of Dialogic or its suppliers and
* licensors. The Material is protected by worldwide copyright and trade secret
* laws and treaty provisions. No part of the Material may be used, copied,
* reproduced, modified, published, uploaded, posted, transmitted, distributed,
* or disclosed in any way without Dialogic's prior express written permission.
*
* No license under any patent, copyright, trade secret or other intellectual
* property right is granted to or conferred upon you by disclosure or delivery
* of the Materials, either expressly, by implication, inducement, estoppel or
* otherwise. Any license under such intellectual property rights must be
* express and approved by Dialogic in writing.
*
***********************************@@@SOFT@@@WARE@@@COPY@@@RIGHT@@@**********/
//***********************************************************************
//***********************************************************************
// StateMachine.cpp: implementation of the CStateMachine class.
//
//////////////////////////////////////////////////////////////////////

#include "pdl.h"
#include "SdpParser.h"

static const char * SDP_MODULE_NAME = "SdpParser";


static NAME_TABLE sdp_table[] = {
	{ "m", SDP_CMD_M },
	{ "i", SDP_CMD_I },
	{ "c", SDP_CMD_C },
	{ "b", SDP_CMD_B },
	{ "k", SDP_CMD_K },
	{ "a", SDP_CMD_A },
	{ "t", SDP_CMD_T },
	{ "r", SDP_CMD_R },
	{ "z", SDP_CMD_Z },

	{ "v", SDP_CMD_V },
	{ "o", SDP_CMD_O },
	{ "s", SDP_CMD_S },
	{ "u", SDP_CMD_U },
	{ "e", SDP_CMD_E },
	{ "p", SDP_CMD_P },
	{ 0  , 0 },
};


//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
//*****************************************************************************
// Purpose	: 
//    Constructor
// Parameters:	
//    none
// Returns:	none
//*****************************************************************************
CSdpParser::CSdpParser(CGenLog *pLog):
            CParser(pLog),
			m_MediaInfo(pLog),
            m_CmdParser(pLog) {
	sdp_o = 0;	// owner/creator
	sdp_s = 0;  // session name
	sdp_a = 0;	// session level attributes
	sdp_u = 0;	// url
	sdp_e = 0;	// email
	sdp_p = 0;	// phone
	sdp_z = 0;	// time zone
	sdp_r = 0;	// time zone

	sdp_tstart=0;
	sdp_tstop = 0;
  clear_vars();
}  //	End of constructor()

//*****************************************************************************
// Purpose	: 
//    Destructor
// Parameters:	
//    none
// Returns:	none
//*****************************************************************************
CSdpParser::~CSdpParser(){
	 clear_vars();
 return;
}//	End of destructor()

//*****************************************************************************
// Purpose	: 
//     Clear internal variables
// Parameters:	
//     None
// Returns:	
//     none
//*****************************************************************************
void CSdpParser::clear_vars(){
  sdp_v = 0;
  str_deletestoredstring(&sdp_o);
  str_deletestoredstring(&sdp_s);
  str_deletestoredstring(&sdp_a);
  str_deletestoredstring(&sdp_u);
  str_deletestoredstring(&sdp_e);
  str_deletestoredstring(&sdp_p);
  str_deletestoredstring(&sdp_z);
  str_deletestoredstring(&sdp_r);

  m_MediaInfo.clear_vars();
  LOG(LOG_DBG, SDP_MODULE_NAME, "ClearVars");
}

//*****************************************************************************
// Purpose	: 
//     skip following '='
// Parameters:	
//     None
// Returns:	
//     success
//***************************************************************************** 
bool CSdpParser::skip_equal(const char *cmd){
  char token[MAXTOKEN];
  if ( ! GetNextToken(token,sizeof(token) )  || 
		( 0 != str_compare(token,"="))    ){
		LOG(LOG_WARNING, SDP_MODULE_NAME,"incomplete sdp descriptor '%s[missing '=']",cmd);
		back();
		return false;
  }
  return true;
}
static NAME_TABLE ipv_addr[] = {
	{"IP4", ADDR_IP4 },
	{"IP6", ADDR_IP6 },
	{ 0,0 }
};
//*****************************************************************************
// Purpose	: 
//     Process command m=
// Parameters:	
//     none
// Returns:	
//     state (STATE_BGN, STATE_MEDIA or STATE_SKIP_MEDIA
//*****************************************************************************
//static NAME_TABLE payload_names[] = {
//    {   "0",        CODER_TYPE_G711ALAW64K },  // GSM
//    {   "9",        CODER_TYPE_G722_48K },     // GSM
//}

//CMediaInfo

P_STATE CnfDemoMediaInfo::ProcessMediaCommand(const char *cmd){
  char token[MAXTOKEN];
  m_CmdParser.SetBuffer(cmd);
    // audio/video/application/data/control
    if (! m_CmdParser.GetNextToken(token,sizeof(token)) ){
	    LOG(LOG_WARNING, SDP_MODULE_NAME, "Invalid command m=[missing media type]");
        return STATE_SKIP_MEDIA;
    }

    if ( 0 != str_compare(token, "audio") ){
	     LOG(LOG_WARNING, SDP_MODULE_NAME, "Unsupported media type %s in command m=(only audio is supported)]", token);
         return  STATE_SKIP_MEDIA;
    }  

    // port 
    if (!m_CmdParser.GetNextToken(token,sizeof(token)) ){
	     LOG(LOG_WARNING, SDP_MODULE_NAME, "Invalid command m=[missing port]");
         return  STATE_SKIP_MEDIA;
    }

    m_CmdParser.GetUNumber(token,&m_remote_port);
    LOG(LOG_DBG, SDP_MODULE_NAME, "remote_port = %d, token = %s", m_remote_port,token);

    // RTP/RTCP
    if (!m_CmdParser.GetNextToken(token,sizeof(token)) ){
	     LOG(LOG_WARNING, SDP_MODULE_NAME, "Invalid command m=[transport]");
         return  STATE_SKIP_MEDIA;
    }

    // Payload (3 (payload type) 97 98 8 0 101)
    // 3: GSM 8000
    // 4:  // Payload is assumed to be whatever is specified in cfg file,
    //    this value is ignored
    

 return STATE_MEDIA;
}
//*****************************************************************************
// Purpose	: 
//     Parse 'c' line
// Parameters:	
//     Parser
// Returns:	
//     none
//*****************************************************************************
bool CnfDemoMediaInfo::Parse_c_line(CSdpParser *pSdpParser ){
char line[MAXTOKEN];
bool brc = false;
   if ( pSdpParser->GetLine(line, sizeof(line)) ){
        str_storestring(&sdp_c, line);
        m_CmdParser.SetBuffer(line);
	    char token[MAXTOKEN];

		// c=IN
		if (! m_CmdParser.GetNextToken(token, sizeof(token)) ){
		      LOG(LOG_WARNING, SDP_MODULE_NAME, "Invalid command c=[missing value]");
              return brc;
        }

		if ( 0 != str_compare(token,"IN")){
		     LOG(LOG_WARNING, SDP_MODULE_NAME, "Invalid command c=[missing IN]");
             return brc;
        }

		// c=IN IP4 ot IP6
		if (! m_CmdParser.GetNextToken(token, sizeof(token)) ){
		      LOG(LOG_WARNING, SDP_MODULE_NAME, "Invalid command c=IN [missing IP4 or IP6]");
              return brc;
        }

		// IP
		if (! m_CmdParser.GetNextToken(sdp_remote_ip, sizeof(sdp_remote_ip)) ){
		      LOG(LOG_WARNING, SDP_MODULE_NAME, "Invalid command c=IN %s [missing ip addr]", token);
              return brc;
        }

		if ( !str_findcode(token,(int *)&sdp_remote_ip_version,ipv_addr) ){
		      LOG(LOG_WARNING, SDP_MODULE_NAME, "Invalid command c=IN [expected IP4 or IP6, found %s]", token);
              return brc;
        }

		if ( sdp_remote_ip_version != ADDR_IP4 ) {
		     LOG(LOG_WARNING, SDP_MODULE_NAME, "Command c= : Only IP4 IP addr is supported in this demo");
		     return brc;
        }
   }    brc = true;
 return brc;
}
//*****************************************************************************
// Purpose	: 
//     Parse Media data lines data from sdp message
// Parameters:	
//     sdp message
// Returns:	
//     none
//*****************************************************************************
bool CnfDemoMediaInfo::ParseMediaDataLines(int sdp_cmd, CSdpParser *pSdpParser ){
  // only m,i,c,b,k,a commands are accepted in both states
  char token[MAXTOKEN];
  bool brc = true; // processed 
  switch(sdp_cmd){
     // i=My session descriptor is a text line