1840 lines
38 KiB
C++
1840 lines
38 KiB
C++
/***************************************************************************************
|
|
*
|
|
* IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
|
*
|
|
* By downloading, copying, installing or using the software you agree to this license.
|
|
* If you do not agree to this license, do not download, install,
|
|
* copy or use the software.
|
|
*
|
|
* Copyright (C) 2014-2024, Happytimesoft Corporation, all rights reserved.
|
|
*
|
|
* Redistribution and use in binary forms, with or without modification, are permitted.
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software distributed
|
|
* under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
|
|
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
|
|
* language governing permissions and limitations under the License.
|
|
*
|
|
****************************************************************************************/
|
|
|
|
#include "sys_inc.h"
|
|
#include "word_analyse.h"
|
|
#include "rtsp_parse.h"
|
|
#include "http_cln.h"
|
|
|
|
/**************************************************************************/
|
|
const RREQMTV rtsp_req_mtvs[] =
|
|
{
|
|
{RTSP_MT_DESCRIBE, "DESCRIBE", 8},
|
|
{RTSP_MT_ANNOUNCE, "ANNOUNCE", 8},
|
|
{RTSP_MT_OPTIONS, "OPTIONS", 7},
|
|
{RTSP_MT_PAUSE, "PAUSE", 5},
|
|
{RTSP_MT_PLAY, "PLAY", 4},
|
|
{RTSP_MT_RECORD, "RECORD", 6},
|
|
{RTSP_MT_REDIRECT, "REDIRECT", 8},
|
|
{RTSP_MT_SETUP, "SETUP", 5},
|
|
{RTSP_MT_SET_PARAMETER, "SET_PARAMETER",13},
|
|
{RTSP_MT_GET_PARAMETER, "GET_PARAMETER",13},
|
|
{RTSP_MT_TEARDOWN, "TEARDOWN", 8}
|
|
};
|
|
|
|
/**************************************************************************/
|
|
BOOL rtsp_is_rtsp_msg(char * msg_buf)
|
|
{
|
|
uint32 i;
|
|
for (i=0; i < sizeof(rtsp_req_mtvs)/sizeof(RREQMTV); i++)
|
|
{
|
|
if (memcmp(msg_buf, rtsp_req_mtvs[i].msg_str, rtsp_req_mtvs[i].msg_len) == 0)
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
if (memcmp(msg_buf, "RTSP/1.0", strlen("RTSP/1.0")) == 0)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void rtsp_headl_parse(char * pline, int llen, HRTSP_MSG * p_msg)
|
|
{
|
|
char word_buf[256];
|
|
int word_len;
|
|
int next_word_offset;
|
|
BOOL bHaveNextWord;
|
|
|
|
bHaveNextWord = GetLineWord(pline, 0, llen, word_buf, sizeof(word_buf), &next_word_offset, WORD_TYPE_STRING);
|
|
word_len = (int)strlen(word_buf);
|
|
if (word_len > 0 && word_len < 31)
|
|
{
|
|
memcpy(p_msg->first_line.header, pline, word_len);
|
|
p_msg->first_line.header[word_len] = '\0';
|
|
|
|
while (pline[next_word_offset] == ' ')
|
|
{
|
|
next_word_offset++;
|
|
}
|
|
|
|
p_msg->first_line.value_string = pline+next_word_offset;
|
|
p_msg->first_line.value_string[llen-next_word_offset] = '\0';
|
|
|
|
if (strcasecmp(word_buf, "RTSP/1.0") == 0)
|
|
{
|
|
if (bHaveNextWord)
|
|
{
|
|
word_len = sizeof(word_buf);
|
|
bHaveNextWord = GetLineWord(pline, next_word_offset, llen, word_buf, sizeof(word_buf), &next_word_offset, WORD_TYPE_NUM);
|
|
word_len = (int)strlen(word_buf);
|
|
if (word_len > 0)
|
|
{
|
|
p_msg->msg_type = 1;
|
|
p_msg->msg_sub_type = atoi(word_buf);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
uint32 i;
|
|
|
|
p_msg->msg_type = 0;
|
|
|
|
for (i=0; i < sizeof(rtsp_req_mtvs)/sizeof(RREQMTV); i++)
|
|
{
|
|
if (strcasecmp(word_buf, (char *)(rtsp_req_mtvs[i].msg_str)) == 0)
|
|
{
|
|
p_msg->msg_sub_type = rtsp_req_mtvs[i].msg_type;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int rtsp_line_parse(char * p_buf, int max_len, char sep_char, PPSN_CTX * p_ctx)
|
|
{
|
|
char word_buf[256];
|
|
BOOL bHaveNextLine = TRUE;
|
|
int line_len = 0;
|
|
int parse_len = 0;
|
|
|
|
char * ptr = p_buf;
|
|
|
|
do {
|
|
if (GetSipLine(ptr, max_len, &line_len, &bHaveNextLine) == FALSE)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if (line_len <= 2)
|
|
{
|
|
return(parse_len + line_len);
|
|
}
|
|
|
|
int next_word_offset = 0;
|
|
GetLineWord(ptr, 0, line_len-2, word_buf, sizeof(word_buf), &next_word_offset, WORD_TYPE_STRING);
|
|
|
|
char nchar = *(ptr + next_word_offset);
|
|
if (nchar != sep_char) // SIP is ':',SDP is '='
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
next_word_offset++;
|
|
while (ptr[next_word_offset] == ' ')
|
|
{
|
|
next_word_offset++;
|
|
}
|
|
|
|
HDRV * pHdrV = hdrv_buf_get_idle();
|
|
if (pHdrV == NULL)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, hdrv_buf_get_idle return NULL!!!\r\n", __FUNCTION__);
|
|
return -1;
|
|
}
|
|
|
|
strncpy(pHdrV->header, word_buf, 31);
|
|
pHdrV->value_string = ptr+next_word_offset;
|
|
pps_ctx_ul_add(p_ctx, pHdrV);
|
|
|
|
ptr += line_len;
|
|
max_len -= line_len;
|
|
parse_len += line_len;
|
|
|
|
while (*ptr == '\r' || *ptr == '\n')
|
|
{
|
|
ptr++;
|
|
parse_len++;
|
|
}
|
|
} while (bHaveNextLine);
|
|
|
|
return parse_len;
|
|
}
|
|
|
|
int rtsp_ctx_parse(HRTSP_MSG * p_msg)
|
|
{
|
|
int flag = 0;
|
|
RTSPCTXT w_ctx_type;
|
|
|
|
HDRV * pHdrV = (HDRV *)pps_lookup_start(&(p_msg->rtsp_ctx));
|
|
while (pHdrV != NULL)
|
|
{
|
|
if (strcasecmp(pHdrV->header, "Content-Length") == 0)
|
|
{
|
|
p_msg->ctx_len = atol(pHdrV->value_string);
|
|
flag++;
|
|
}
|
|
else if (strcasecmp(pHdrV->header, "Content-Type") == 0)
|
|
{
|
|
char type_word[64];
|
|
int next_tmp;
|
|
GetLineWord(pHdrV->value_string, 0, (int)strlen(pHdrV->value_string), type_word, sizeof(type_word), &next_tmp, WORD_TYPE_STRING);
|
|
|
|
if (strcasecmp(type_word, "application/sdp") == 0)
|
|
{
|
|
w_ctx_type = RTSP_CTX_SDP;
|
|
}
|
|
else
|
|
{
|
|
w_ctx_type = RTSP_CTX_NULL;
|
|
}
|
|
|
|
p_msg->ctx_type = w_ctx_type;
|
|
flag++;
|
|
}
|
|
|
|
pHdrV = (HDRV *)pps_lookup_next(&(p_msg->rtsp_ctx), pHdrV);
|
|
}
|
|
pps_lookup_end(&(p_msg->rtsp_ctx));
|
|
|
|
if (p_msg->ctx_type && p_msg->ctx_len)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int rtsp_msg_parse(char * msg_buf, int msg_buf_len, HRTSP_MSG * msg)
|
|
{
|
|
int line_len = 0;
|
|
BOOL bHaveNextLine;
|
|
char * p_buf = msg_buf;
|
|
|
|
msg->msg_type = (uint32) -1;
|
|
|
|
if (GetSipLine(p_buf, msg_buf_len, &line_len, &bHaveNextLine) == FALSE)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if (line_len > 0)
|
|
{
|
|
rtsp_headl_parse(p_buf, line_len-2, msg);
|
|
}
|
|
|
|
if (msg->msg_type == (uint32) -1)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
p_buf += line_len;
|
|
msg->rtsp_len = rtsp_line_parse(p_buf, msg_buf_len-line_len, ':', &(msg->rtsp_ctx));
|
|
if (msg->rtsp_len <= 0)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
p_buf += msg->rtsp_len;
|
|
|
|
if (rtsp_ctx_parse(msg) == 1 && msg->ctx_len > 0)
|
|
{
|
|
msg->sdp_len = rtsp_line_parse(p_buf, msg->ctx_len, '=', &(msg->sdp_ctx));
|
|
if (msg->sdp_len < 0)
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
return (line_len + msg->rtsp_len + msg->sdp_len);
|
|
}
|
|
|
|
int rtsp_msg_parse_part1(char * p_buf, int buf_len, HRTSP_MSG * msg)
|
|
{
|
|
int line_len = 0;
|
|
BOOL bHaveNextLine;
|
|
|
|
msg->msg_type = (uint32) -1;
|
|
|
|
if (GetSipLine(p_buf, buf_len, &line_len, &bHaveNextLine) == FALSE)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if (line_len > 0)
|
|
{
|
|
rtsp_headl_parse(p_buf, line_len-2, msg);
|
|
}
|
|
|
|
if (msg->msg_type == (uint32) -1)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
p_buf += line_len;
|
|
msg->rtsp_len = rtsp_line_parse(p_buf, buf_len-line_len, ':', &(msg->rtsp_ctx));
|
|
if (msg->rtsp_len <= 0)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
rtsp_ctx_parse(msg);
|
|
|
|
return (line_len + msg->rtsp_len);
|
|
}
|
|
|
|
int rtsp_msg_parse_part2(char * p_buf, int buf_len, HRTSP_MSG * msg)
|
|
{
|
|
msg->sdp_len = rtsp_line_parse(p_buf, buf_len, '=', &(msg->sdp_ctx));
|
|
if (msg->sdp_len < 0)
|
|
{
|
|
msg->sdp_len = rtsp_line_parse(p_buf, buf_len, ':', &(msg->sdp_ctx));
|
|
if (msg->sdp_len < 0)
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
return msg->sdp_len;
|
|
}
|
|
|
|
HDRV * rtsp_find_headline(HRTSP_MSG * msg, const char * head)
|
|
{
|
|
if (msg == NULL || head == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
HDRV * line = (HDRV *)pps_lookup_start(&(msg->rtsp_ctx));
|
|
while (line != NULL)
|
|
{
|
|
if (strcasecmp(line->header, head) == 0)
|
|
{
|
|
return line;
|
|
}
|
|
|
|
line = (HDRV *)pps_lookup_next(&(msg->rtsp_ctx), line);
|
|
}
|
|
pps_lookup_end(&(msg->rtsp_ctx));
|
|
|
|
return NULL;
|
|
}
|
|
|
|
HDRV * rtsp_find_headline_next(HRTSP_MSG * msg, const char * head, HDRV * hrv)
|
|
{
|
|
HDRV * line;
|
|
|
|
if (msg == NULL || head == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
line = (HDRV *)pps_lookup_start(&(msg->rtsp_ctx));
|
|
while (line != NULL)
|
|
{
|
|
if (line == hrv)
|
|
{
|
|
line = (HDRV *)pps_lookup_next(&(msg->rtsp_ctx), line);
|
|
break;
|
|
}
|
|
|
|
line = (HDRV *)pps_lookup_next(&(msg->rtsp_ctx), line);
|
|
}
|
|
|
|
while (line != NULL)
|
|
{
|
|
if (strcasecmp(line->header, head) == 0)
|
|
{
|
|
pps_lookup_end(&(msg->rtsp_ctx));
|
|
return line;
|
|
}
|
|
|
|
line = (HDRV *)pps_lookup_next(&(msg->rtsp_ctx), line);
|
|
}
|
|
pps_lookup_end(&(msg->rtsp_ctx));
|
|
|
|
return NULL;
|
|
}
|
|
|
|
BOOL rtsp_get_headline_string(HRTSP_MSG * rx_msg, const char * head, char * p_value, int size)
|
|
{
|
|
HDRV * rx_head = rtsp_find_headline(rx_msg, head);
|
|
if (rx_head == NULL || p_value == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (rx_head->value_string == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
p_value[0] = '\0';
|
|
|
|
int len = (int)strlen(rx_head->value_string);
|
|
if (len >= size)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, %s, value_string(%s) len(%d) > size(%d)\r\n",
|
|
__FUNCTION__, head, rx_head->value_string, len, size);
|
|
return FALSE;
|
|
}
|
|
|
|
strcpy(p_value, rx_head->value_string);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL rtsp_get_headline_uri(HRTSP_MSG * rx_msg, char * p_uri, int size)
|
|
{
|
|
char * p_ptr = rx_msg->first_line.value_string;
|
|
if (p_ptr == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
char * p_end = p_ptr;
|
|
while (*p_end != ' ')
|
|
{
|
|
p_end++;
|
|
}
|
|
|
|
int len = (int)(p_end - p_ptr);
|
|
if (len >= size)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
memcpy(p_uri, p_ptr, len);
|
|
p_uri[len] = '\0';
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
HDRV * rtsp_find_sdp_headline(HRTSP_MSG * msg, const char * head)
|
|
{
|
|
if (msg == NULL || head == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
HDRV * line = (HDRV *)pps_lookup_start(&(msg->sdp_ctx));
|
|
while (line != NULL)
|
|
{
|
|
if (strcasecmp(line->header, head) == 0)
|
|
{
|
|
return line;
|
|
}
|
|
|
|
line = (HDRV *)pps_lookup_next(&(msg->sdp_ctx), line);
|
|
}
|
|
pps_lookup_end(&(msg->sdp_ctx));
|
|
|
|
return NULL;
|
|
}
|
|
|
|
BOOL rtsp_msg_with_sdp(HRTSP_MSG * msg)
|
|
{
|
|
if (msg == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (msg->sdp_ctx.node_num == 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL rtsp_get_msg_session(HRTSP_MSG * rx_msg, char *session_buf, int len)
|
|
{
|
|
session_buf[0] = '\0';
|
|
|
|
HDRV * rx_id = rtsp_find_headline(rx_msg, "Session");
|
|
if (rx_id == NULL || len <= 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
int next_word_offset;
|
|
|
|
GetLineWord(rx_id->value_string, 0, (int)strlen(rx_id->value_string), session_buf, len, &next_word_offset, WORD_TYPE_STRING);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL rtsp_match_msg_session(HRTSP_MSG * rx_msg, HRTSP_MSG * tx_msg)
|
|
{
|
|
HDRV * rx_id = rtsp_find_headline(rx_msg, "Session");
|
|
HDRV * tx_id = rtsp_find_headline(tx_msg, "Session");
|
|
|
|
if (rx_id == NULL || tx_id == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
char rx_word_buf[256];
|
|
char tx_word_buf[256];
|
|
int next_word_offset;
|
|
|
|
GetLineWord(rx_id->value_string, 0, (int)strlen(rx_id->value_string),
|
|
rx_word_buf, sizeof(rx_word_buf), &next_word_offset, WORD_TYPE_STRING);
|
|
GetLineWord(tx_id->value_string, 0, (int)strlen(tx_id->value_string),
|
|
tx_word_buf, sizeof(tx_word_buf), &next_word_offset, WORD_TYPE_STRING);
|
|
|
|
if (strcmp(rx_word_buf, tx_word_buf) != 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL rtsp_match_msg_cseq(HRTSP_MSG * rx_msg, HRTSP_MSG * tx_msg)
|
|
{
|
|
HDRV * rx_cseq = rtsp_find_headline(rx_msg, "CSeq");
|
|
HDRV * tx_cseq = rtsp_find_headline(tx_msg, "CSeq");
|
|
|
|
if (rx_cseq == NULL || tx_cseq == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
char rx_word_buf[256];
|
|
char tx_word_buf[256];
|
|
int next_offset;
|
|
|
|
GetLineWord(rx_cseq->value_string, 0, (int)strlen(rx_cseq->value_string),
|
|
rx_word_buf, sizeof(rx_word_buf), &next_offset, WORD_TYPE_NUM);
|
|
GetLineWord(tx_cseq->value_string, 0, (int)strlen(tx_cseq->value_string),
|
|
tx_word_buf, sizeof(tx_word_buf), &next_offset, WORD_TYPE_NUM);
|
|
|
|
if (strcmp(rx_word_buf, tx_word_buf) != 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
GetLineWord(rx_cseq->value_string, next_offset, (int)strlen(rx_cseq->value_string),
|
|
rx_word_buf, sizeof(rx_word_buf), &next_offset, WORD_TYPE_STRING);
|
|
GetLineWord(tx_cseq->value_string, next_offset, (int)strlen(tx_cseq->value_string),
|
|
tx_word_buf, sizeof(tx_word_buf), &next_offset, WORD_TYPE_STRING);
|
|
|
|
if (strcasecmp(rx_word_buf, tx_word_buf) != 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL rtsp_get_msg_cseq(HRTSP_MSG * rx_msg, char *cseq_buf, int len)
|
|
{
|
|
HDRV * rx_cseq = rtsp_find_headline(rx_msg, "CSeq");
|
|
if ((rx_cseq == NULL) || len <= 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
int next_offset;
|
|
|
|
GetLineWord(rx_cseq->value_string, 0, (int)strlen(rx_cseq->value_string), cseq_buf, len, &next_offset, WORD_TYPE_NUM);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL rtsp_get_user_agent_info(HRTSP_MSG * rx_msg, char * agent_buf, int max_len)
|
|
{
|
|
if (agent_buf == NULL || max_len <= 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
agent_buf[0] = '\0';
|
|
|
|
HDRV * rx_line = rtsp_find_headline(rx_msg, "User-Agent");
|
|
if (rx_line == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
strncpy(agent_buf, rx_line->value_string, max_len);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL rtsp_get_session_info(HRTSP_MSG * rx_msg, char * session_buf, int max_len, int * timeout)
|
|
{
|
|
if (session_buf == NULL || max_len <= 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
HDRV * rx_line = rtsp_find_headline(rx_msg, "Session");
|
|
if (rx_line == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
session_buf[0] = '\0';
|
|
|
|
if (rx_line->value_string)
|
|
{
|
|
char * p = strchr(rx_line->value_string, ';');
|
|
if (!p)
|
|
{
|
|
strncpy(session_buf, rx_line->value_string, max_len);
|
|
}
|
|
else
|
|
{
|
|
*p = '\0';
|
|
strncpy(session_buf, rx_line->value_string, max_len);
|
|
*p = ';';
|
|
}
|
|
|
|
if (timeout)
|
|
{
|
|
char value_string[256] = {'\0'};
|
|
strncpy(value_string, rx_line->value_string, sizeof(value_string)-1);
|
|
lowercase(value_string);
|
|
|
|
p = strstr(value_string, "timeout=");
|
|
if (p)
|
|
{
|
|
p += strlen("timeout=");
|
|
*timeout = atoi(p);
|
|
|
|
if (*timeout <= 0)
|
|
{
|
|
*timeout = 60;
|
|
}
|
|
else if (*timeout < 10)
|
|
{
|
|
*timeout = 10;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL rtsp_get_rtp_info(HRTSP_MSG * rx_msg, char * v_ctl, uint32 * p_v_ts, char * a_ctl, uint32 * p_a_ts)
|
|
{
|
|
HDRV * rx_line = rtsp_find_headline(rx_msg, "RTP-Info");
|
|
if (rx_line == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (NULL == rx_line->value_string)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// set default value -1
|
|
*p_v_ts = -1;
|
|
*p_a_ts = -1;
|
|
|
|
if (v_ctl && v_ctl[0] != '\0')
|
|
{
|
|
int ctl_len;
|
|
char * p = strchr(v_ctl, '?');
|
|
if (p)
|
|
{
|
|
char ctl[128] = {'\0'};
|
|
strncpy(ctl, v_ctl, p-v_ctl);
|
|
|
|
p = strstr(rx_line->value_string, ctl);
|
|
ctl_len = strlen(ctl);
|
|
}
|
|
else
|
|
{
|
|
p = strstr(rx_line->value_string, v_ctl);
|
|
ctl_len = strlen(v_ctl);
|
|
}
|
|
|
|
if (p)
|
|
{
|
|
p += ctl_len;
|
|
|
|
int i = 0, j = 0;
|
|
char * p_buff = NULL;
|
|
char * p_semicolon = strchr(p, ',');
|
|
char * p_rtptime = strstr(p, "rtptime=");
|
|
char rtptime[32] = {'\0'};
|
|
|
|
if (p_rtptime)
|
|
{
|
|
if (p_semicolon)
|
|
{
|
|
if (p_rtptime < p_semicolon)
|
|
{
|
|
p_buff = p_rtptime+strlen("rtptime=");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
p_buff = p_rtptime+strlen("rtptime=");
|
|
}
|
|
|
|
while (p_buff && p_buff[i] != '\0')
|
|
{
|
|
if (p_buff[i] == ',' || p_buff[i] == ';')
|
|
{
|
|
break;
|
|
}
|
|
else if (j < 31)
|
|
{
|
|
rtptime[j++] = p_buff[i];
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
*p_v_ts = (uint32)strtoul(rtptime, NULL, 10);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (a_ctl && a_ctl[0] != '\0')
|
|
{
|
|
int ctl_len;
|
|
char * p = strchr(a_ctl, '?');
|
|
if (p)
|
|
{
|
|
char ctl[128] = {'\0'};
|
|
strncpy(ctl, a_ctl, p-a_ctl);
|
|
|
|
p = strstr(rx_line->value_string, ctl);
|
|
ctl_len = strlen(ctl);
|
|
}
|
|
else
|
|
{
|
|
p = strstr(rx_line->value_string, a_ctl);
|
|
ctl_len = strlen(a_ctl);
|
|
}
|
|
|
|
if (p)
|
|
{
|
|
p += ctl_len;
|
|
|
|
int i = 0, j = 0;
|
|
char * p_buff = NULL;
|
|
char * p_semicolon = strchr(p, ',');
|
|
char * p_rtptime = strstr(p, "rtptime=");
|
|
char rtptime[32] = {'\0'};
|
|
|
|
if (p_rtptime)
|
|
{
|
|
if (p_semicolon)
|
|
{
|
|
if (p_rtptime < p_semicolon)
|
|
{
|
|
p_buff = p_rtptime+strlen("rtptime=");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
p_buff = p_rtptime+strlen("rtptime=");
|
|
}
|
|
|
|
while (p_buff && p_buff[i] != '\0')
|
|
{
|
|
if (p_buff[i] == ',' || p_buff[i] == ';')
|
|
{
|
|
break;
|
|
}
|
|
else if (j < 31)
|
|
{
|
|
rtptime[j++] = p_buff[i];
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
*p_a_ts = (uint32)strtoul(rtptime, NULL, 10);
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL rtsp_get_tcp_transport_info(HRTSP_MSG * rx_msg, uint16 * interleaved)
|
|
{
|
|
BOOL ret = FALSE;
|
|
|
|
HDRV * rx_line = rtsp_find_headline(rx_msg, "Transport");
|
|
if (rx_line == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (rx_line->value_string)
|
|
{
|
|
char buff[32] = {'\0'};
|
|
if (GetNameValuePair(rx_line->value_string, (int)strlen(rx_line->value_string), "interleaved", buff, sizeof(buff)-1))
|
|
{
|
|
if (interleaved)
|
|
{
|
|
*interleaved = atoi(buff);
|
|
}
|
|
|
|
ret = TRUE;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
BOOL rtsp_get_udp_transport_info(HRTSP_MSG * rx_msg, uint16 * client_port, uint16 * server_port)
|
|
{
|
|
BOOL ret = FALSE;
|
|
|
|
HDRV * rx_line = rtsp_find_headline(rx_msg, "Transport");
|
|
if (rx_line == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (rx_line->value_string)
|
|
{
|
|
char buff[32] = {'\0'};
|
|
if (GetNameValuePair(rx_line->value_string, (int)strlen(rx_line->value_string), "client_port", buff, sizeof(buff)-1))
|
|
{
|
|
if (client_port)
|
|
{
|
|
*client_port = atoi(buff);
|
|
}
|
|
|
|
ret = TRUE;
|
|
}
|
|
|
|
if (GetNameValuePair(rx_line->value_string, (int)strlen(rx_line->value_string), "server_port", buff, sizeof(buff)-1))
|
|
{
|
|
if (server_port)
|
|
{
|
|
*server_port = atoi(buff);
|
|
}
|
|
|
|
ret = TRUE;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
BOOL rtsp_get_mc_transport_info(HRTSP_MSG * rx_msg, char * destination, uint16 * port)
|
|
{
|
|
BOOL ret = FALSE;
|
|
|
|
HDRV * rx_line = rtsp_find_headline(rx_msg, "Transport");
|
|
if (rx_line == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (rx_line->value_string)
|
|
{
|
|
char buff[32] = {'\0'};
|
|
if (GetNameValuePair(rx_line->value_string, (int)strlen(rx_line->value_string), "destination", buff, sizeof(buff)-1))
|
|
{
|
|
if (destination)
|
|
{
|
|
strcpy(destination, buff);
|
|
}
|
|
|
|
ret = TRUE;
|
|
}
|
|
|
|
if (GetNameValuePair(rx_line->value_string, (int)strlen(rx_line->value_string), "port", buff, sizeof(buff)-1))
|
|
{
|
|
if (port)
|
|
{
|
|
*port = atoi(buff);
|
|
}
|
|
|
|
ret = TRUE;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
BOOL rtsp_is_line_exist(HRTSP_MSG * rx_msg, const char * head, const char * value)
|
|
{
|
|
char buf[256];
|
|
char lovalue[256] = {'\0'};
|
|
|
|
if (!rtsp_get_headline_string(rx_msg, head, buf, sizeof(buf)))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
strncpy(lovalue, value, sizeof(lovalue)-1);
|
|
|
|
lowercase(buf);
|
|
lowercase(lovalue);
|
|
|
|
if (!strstr(buf, lovalue))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL rtsp_get_cbase_info(HRTSP_MSG * rx_msg, char * cbase_buf, int max_len)
|
|
{
|
|
if (cbase_buf == NULL || max_len <= 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
cbase_buf[0] = '\0';
|
|
|
|
HDRV * rx_line = rtsp_find_headline(rx_msg, "Content-Base");
|
|
if (rx_line == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
strncpy(cbase_buf, rx_line->value_string, max_len);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void rtsp_add_tx_msg_line(HRTSP_MSG * tx_msg, const char * msg_hdr, const char * msg_fmt, ...)
|
|
{
|
|
int slen;
|
|
va_list argptr;
|
|
|
|
if (tx_msg == NULL || tx_msg->msg_buf == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
HDRV *pHdrV = hdrv_buf_get_idle();
|
|
if (pHdrV == NULL)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, hdrv_buf_get_idle return NULL!!!\r\n", __FUNCTION__);
|
|
return;
|
|
}
|
|
|
|
pHdrV->value_string = tx_msg->msg_buf + tx_msg->buf_offset;
|
|
|
|
strncpy(pHdrV->header, msg_hdr, 31);
|
|
|
|
va_start(argptr, msg_fmt);
|
|
|
|
#if __LINUX_OS__
|
|
slen = vsnprintf(pHdrV->value_string, 1600-tx_msg->buf_offset, msg_fmt, argptr);
|
|
#else
|
|
slen = vsprintf(pHdrV->value_string, msg_fmt, argptr);
|
|
#endif
|
|
|
|
va_end(argptr);
|
|
|
|
if (slen < 0)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, vsnprintf return %d !!!\r\n", __FUNCTION__, slen);
|
|
hdrv_buf_free(pHdrV);
|
|
return;
|
|
}
|
|
|
|
pHdrV->value_string[slen] = '\0';
|
|
tx_msg->buf_offset += slen + 1;
|
|
|
|
pps_ctx_ul_add(&(tx_msg->rtsp_ctx), pHdrV);
|
|
}
|
|
|
|
void rtsp_add_tx_msg_sdp_line(HRTSP_MSG * tx_msg, const char * msg_hdr, const char * msg_fmt, ...)
|
|
{
|
|
int slen;
|
|
va_list argptr;
|
|
|
|
if (tx_msg == NULL || tx_msg->msg_buf == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
HDRV *pHdrV = hdrv_buf_get_idle();
|
|
if (pHdrV == NULL)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, hdrv_buf_get_idle return NULL!!!\r\n", __FUNCTION__);
|
|
return;
|
|
}
|
|
|
|
pHdrV->value_string = tx_msg->msg_buf + tx_msg->buf_offset;
|
|
|
|
strncpy(pHdrV->header, msg_hdr, 31);
|
|
|
|
va_start(argptr, msg_fmt);
|
|
|
|
#if __LINUX_OS__
|
|
slen = vsnprintf(pHdrV->value_string, 1600-tx_msg->buf_offset, msg_fmt, argptr);
|
|
#else
|
|
slen = vsprintf(pHdrV->value_string, msg_fmt, argptr);
|
|
#endif
|
|
|
|
va_end(argptr);
|
|
|
|
if (slen < 0)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, vsnprintf return %d !!!\r\n", __FUNCTION__, slen);
|
|
hdrv_buf_free(pHdrV);
|
|
return;
|
|
}
|
|
|
|
pHdrV->value_string[slen] = '\0';
|
|
tx_msg->buf_offset += slen + 1;
|
|
|
|
pps_ctx_ul_add(&(tx_msg->sdp_ctx), pHdrV);
|
|
}
|
|
|
|
void rtsp_add_tx_msg_fline(HRTSP_MSG * tx_msg, const char * msg_hdr, const char * msg_fmt, ...)
|
|
{
|
|
int slen;
|
|
va_list argptr;
|
|
|
|
if (tx_msg == NULL || tx_msg->msg_buf == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
strncpy(tx_msg->first_line.header, msg_hdr, sizeof(tx_msg->first_line.header)-1);
|
|
tx_msg->first_line.value_string = tx_msg->msg_buf + tx_msg->buf_offset;
|
|
|
|
va_start(argptr, msg_fmt);
|
|
#if __LINUX_OS__
|
|
slen = vsnprintf(tx_msg->first_line.value_string, 1600-tx_msg->buf_offset, msg_fmt, argptr);
|
|
#else
|
|
slen = vsprintf(tx_msg->first_line.value_string, msg_fmt, argptr);
|
|
#endif
|
|
va_end(argptr);
|
|
|
|
if (slen < 0)
|
|
{
|
|
log_print(HT_LOG_ERR, "%s, vsnprintf return %d !!!\r\n", __FUNCTION__, slen);
|
|
return;
|
|
}
|
|
|
|
tx_msg->first_line.value_string[slen] = '\0';
|
|
|
|
tx_msg->buf_offset += slen + 1;
|
|
}
|
|
|
|
void rtsp_copy_msg_line(HRTSP_MSG * src_msg, HRTSP_MSG * dst_msg, char * msg_hdr)
|
|
{
|
|
HDRV * src_line = rtsp_find_headline(src_msg, msg_hdr);
|
|
if (src_line == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
HDRV * dst_line = hdrv_buf_get_idle();
|
|
if (dst_line == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
strcpy(dst_line->header, src_line->header);
|
|
|
|
dst_line->value_string = dst_msg->msg_buf + dst_msg->buf_offset;
|
|
if (dst_line->value_string == NULL)
|
|
{
|
|
hdrv_buf_free(dst_line);
|
|
return;
|
|
}
|
|
|
|
strcpy(dst_line->value_string, src_line->value_string);
|
|
dst_msg->buf_offset += (int)strlen(src_line->value_string) + 1;
|
|
|
|
pps_ctx_ul_add(&(dst_msg->rtsp_ctx), dst_line);
|
|
}
|
|
|
|
void rtsp_free_msg(HRTSP_MSG * msg)
|
|
{
|
|
if (msg == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
rtsp_free_msg_content(msg);
|
|
rtsp_free_msg_buf(msg);
|
|
}
|
|
|
|
void rtsp_free_msg_content(HRTSP_MSG * msg)
|
|
{
|
|
if (msg == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
hdrv_ctx_free(&(msg->rtsp_ctx));
|
|
hdrv_ctx_free(&(msg->sdp_ctx));
|
|
|
|
net_buf_free(msg->msg_buf);
|
|
}
|
|
|
|
BOOL rtsp_get_remote_media_ip(HRTSP_MSG * rx_msg, uint32 * media_ip)
|
|
{
|
|
HDRV * pHdr = rtsp_find_sdp_headline(rx_msg, "c");
|
|
if ((pHdr != NULL) && (pHdr->value_string != NULL) && (strlen(pHdr->value_string) > 0))
|
|
{
|
|
char tmp_buf[128];
|
|
int next_offset;
|
|
|
|
GetLineWord(pHdr->value_string, 0, (int)strlen(pHdr->value_string),
|
|
tmp_buf, sizeof(tmp_buf), &next_offset, WORD_TYPE_STRING);
|
|
if (strcasecmp(tmp_buf, "IN") != 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
GetLineWord(pHdr->value_string, next_offset, (int)strlen(pHdr->value_string),
|
|
tmp_buf, sizeof(tmp_buf), &next_offset, WORD_TYPE_STRING);
|
|
if (strcasecmp(tmp_buf, "IP4") != 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
GetLineWord(pHdr->value_string, next_offset, (int)strlen(pHdr->value_string),
|
|
tmp_buf, sizeof(tmp_buf), &next_offset, WORD_TYPE_STRING);
|
|
|
|
log_print(HT_LOG_DBG, "%s, media_ip=%s\r\n", __FUNCTION__, tmp_buf);
|
|
|
|
if (is_ip_address(tmp_buf))
|
|
{
|
|
*media_ip = inet_addr(tmp_buf);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
HDRV * rtsp_find_mdesc_point(HRTSP_MSG * rx_msg, HDRV * pStartHdr, const char * cap_name, int * next_offset, const char * attr)
|
|
{
|
|
char media_type[16];
|
|
HDRV * pHdr = pStartHdr;
|
|
HDRV * pHdr1 = NULL;
|
|
|
|
for (; pHdr != NULL; pHdr = (HDRV *)pps_lookup_next(&(rx_msg->sdp_ctx),pHdr))
|
|
{
|
|
if (strcasecmp(pHdr->header, "m") != 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
GetLineWord(pHdr->value_string, 0, (int)strlen(pHdr->value_string), media_type, sizeof(media_type), next_offset, WORD_TYPE_STRING);
|
|
|
|
if (strcasecmp(media_type, cap_name) != 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (NULL == attr)
|
|
{
|
|
return pHdr;
|
|
}
|
|
|
|
pHdr1 = (HDRV *)pps_lookup_next(&(rx_msg->sdp_ctx), pHdr);
|
|
|
|
for (; pHdr1 != NULL; pHdr1 = (HDRV *)pps_lookup_next(&(rx_msg->sdp_ctx), pHdr1))
|
|
{
|
|
if (strcasecmp(pHdr1->header, "m") == 0)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (pHdr1->value_string && (pHdr1->header[0] == 'a') && (memcmp(pHdr1->value_string, attr, strlen(attr)) == 0))
|
|
{
|
|
return pHdr;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
BOOL rtsp_get_remote_cap(HRTSP_MSG * rx_msg, const char * cap_name, int * cap_count, uint8 * cap_array, uint16 * rtp_port, const char * attr)
|
|
{
|
|
int next_offset = 0;
|
|
char media_port[16],tmp_buf[64];
|
|
|
|
*cap_count = 0;
|
|
|
|
HDRV * pHdr = (HDRV *)pps_lookup_start(&(rx_msg->sdp_ctx));
|
|
|
|
pHdr = rtsp_find_mdesc_point(rx_msg, pHdr, cap_name, &next_offset, attr);
|
|
if (pHdr == NULL)
|
|
{
|
|
pps_lookup_end(&(rx_msg->sdp_ctx));
|
|
return FALSE;
|
|
}
|
|
|
|
GetLineWord(pHdr->value_string, next_offset, (int)strlen(pHdr->value_string),
|
|
media_port, sizeof(media_port), &next_offset, WORD_TYPE_NUM);
|
|
|
|
GetLineWord(pHdr->value_string, next_offset, (int)strlen(pHdr->value_string),
|
|
tmp_buf, sizeof(tmp_buf), &next_offset, WORD_TYPE_STRING);
|
|
|
|
if (strcasecmp(tmp_buf, "RTP/AVP") != 0)
|
|
{
|
|
pps_lookup_end(&(rx_msg->sdp_ctx));
|
|
return FALSE;
|
|
}
|
|
|
|
int count = 0;
|
|
BOOL cap_next_flag = TRUE;
|
|
|
|
do {
|
|
cap_next_flag = GetLineWord(pHdr->value_string, next_offset, (int)strlen(pHdr->value_string),
|
|
tmp_buf, sizeof(tmp_buf), &next_offset, WORD_TYPE_NUM);
|
|
if (tmp_buf[0] != '\0')
|
|
{
|
|
if (count >= MAX_AVN)
|
|
{
|
|
pps_lookup_end(&(rx_msg->sdp_ctx));
|
|
return FALSE;
|
|
}
|
|
|
|
cap_array[count++] = (uint8)atol(tmp_buf);
|
|
*cap_count = count;
|
|
}
|
|
} while (cap_next_flag);
|
|
|
|
if (count > 0)
|
|
{
|
|
if (rtp_port)
|
|
{
|
|
*rtp_port = (uint16)atol(media_port);
|
|
}
|
|
|
|
pps_lookup_end(&(rx_msg->sdp_ctx));
|
|
return TRUE;
|
|
}
|
|
|
|
pps_lookup_end(&(rx_msg->sdp_ctx));
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL rtsp_get_digest_info(HRTSP_MSG * rx_msg, HD_AUTH_INFO * p_auth)
|
|
{
|
|
int len;
|
|
int next_offset;
|
|
char word_buf[128];
|
|
HDRV * chap_id = NULL;
|
|
char * p;
|
|
|
|
p_auth->auth_response[0] = '\0';
|
|
|
|
RETRY:
|
|
|
|
if (chap_id)
|
|
{
|
|
chap_id = rtsp_find_headline_next(rx_msg, "WWW-Authenticate", chap_id);
|
|
}
|
|
else
|
|
{
|
|
chap_id = rtsp_find_headline(rx_msg, "WWW-Authenticate");
|
|
}
|
|
|
|
if (chap_id == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
GetLineWord(chap_id->value_string, 0, (int)strlen(chap_id->value_string),
|
|
word_buf, sizeof(word_buf), &next_offset, WORD_TYPE_STRING);
|
|
if (strcasecmp(word_buf, "digest") != 0)
|
|
{
|
|
goto RETRY;
|
|
}
|
|
|
|
p = chap_id->value_string + next_offset;
|
|
len = (int)strlen(chap_id->value_string) - next_offset;
|
|
|
|
if (!http_get_digest_params(p, len, p_auth))
|
|
{
|
|
goto RETRY;
|
|
}
|
|
|
|
if (p_auth->auth_algorithm[0] != '\0' &&
|
|
strncasecmp(p_auth->auth_algorithm, "MD5", 3) &&
|
|
strncasecmp(p_auth->auth_algorithm, "SHA-256", 7))
|
|
{
|
|
goto RETRY;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL rtsp_get_auth_digest_info(HRTSP_MSG * rx_msg, HD_AUTH_INFO * p_auth)
|
|
{
|
|
int len;
|
|
int next_offset;
|
|
char word_buf[128];
|
|
char * p;
|
|
|
|
HDRV * res_line = rtsp_find_headline(rx_msg, "Authorization");
|
|
if (res_line == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
GetLineWord(res_line->value_string, 0, (int)strlen(res_line->value_string),
|
|
word_buf, sizeof(word_buf), &next_offset, WORD_TYPE_STRING);
|
|
|
|
if (strcasecmp(word_buf, "digest") != 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
p = res_line->value_string + next_offset;
|
|
len = (int)strlen(res_line->value_string) - next_offset;
|
|
|
|
if (!GetNameValuePair(p, len, "username", p_auth->auth_name, sizeof(p_auth->auth_name)))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (!GetNameValuePair(p, len, "realm", p_auth->auth_realm, sizeof(p_auth->auth_realm)))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (!GetNameValuePair(p, len, "nonce", p_auth->auth_nonce, sizeof(p_auth->auth_nonce)))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (!GetNameValuePair(p, len, "uri", p_auth->auth_uri, sizeof(p_auth->auth_uri)))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (!GetNameValuePair(p, len, "response", p_auth->auth_response, sizeof(p_auth->auth_response)))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (!GetNameValuePair(p, len, "algorithm", p_auth->auth_algorithm, sizeof(p_auth->auth_algorithm)))
|
|
{
|
|
p_auth->auth_algorithm[0] = '\0';
|
|
}
|
|
|
|
if (GetNameValuePair(p, len, "qop", p_auth->auth_qop, sizeof(p_auth->auth_qop)))
|
|
{
|
|
char * stop_string;
|
|
|
|
if (!GetNameValuePair(p, len, "cnonce", p_auth->auth_cnonce, sizeof(p_auth->auth_cnonce)))
|
|
{
|
|
p_auth->auth_cnonce[0] = '\0';
|
|
}
|
|
|
|
if (!GetNameValuePair(p, len, "nc", p_auth->auth_ncstr, sizeof(p_auth->auth_ncstr)))
|
|
{
|
|
p_auth->auth_ncstr[0] = '\0';
|
|
}
|
|
|
|
p_auth->auth_nc = strtol(p_auth->auth_ncstr, &stop_string, 16);
|
|
|
|
if (strlen(stop_string) > 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
p_auth->auth_qop[0] = '\0';
|
|
p_auth->auth_cnonce[0] = '\0';
|
|
p_auth->auth_ncstr[0] = '\0';
|
|
p_auth->auth_nc = 0;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL rtsp_get_remote_cap_desc(HRTSP_MSG * rx_msg, const char * cap_name, char cap_desc[][MAX_AVDESCLEN], const char * attr)
|
|
{
|
|
int next_offset = 0;
|
|
int index = 0;
|
|
|
|
HDRV * pHdr = (HDRV *)pps_lookup_start(&(rx_msg->sdp_ctx));
|
|
|
|
pHdr = rtsp_find_mdesc_point(rx_msg, pHdr, cap_name, &next_offset, attr);
|
|
if (pHdr == NULL)
|
|
{
|
|
pps_lookup_end(&(rx_msg->sdp_ctx));
|
|
return FALSE;
|
|
}
|
|
|
|
for (index=0; index<MAX_AVN; index++)
|
|
{
|
|
cap_desc[index][0] = '\0';
|
|
}
|
|
|
|
index = 0;
|
|
pHdr = (HDRV *)pps_lookup_next(&(rx_msg->sdp_ctx), pHdr);
|
|
while (pHdr != NULL)
|
|
{
|
|
if (strcasecmp(pHdr->header, "m") == 0)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (index >= MAX_AVN)
|
|
{
|
|
break;
|
|
}
|
|
|
|
snprintf(cap_desc[index], MAX_AVDESCLEN, "%s=%s", pHdr->header, pHdr->value_string);
|
|
|
|
index++;
|
|
|
|
pHdr = (HDRV *)pps_lookup_next(&(rx_msg->sdp_ctx), pHdr);
|
|
}
|
|
|
|
pps_lookup_end(&(rx_msg->sdp_ctx));
|
|
|
|
return (index != 0);
|
|
}
|
|
|
|
BOOL rtsp_find_sdp_control(HRTSP_MSG * rx_msg, char * ctl_buf, const char * tname, int max_len, const char *attr)
|
|
{
|
|
if (rx_msg == NULL || ctl_buf == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
int next_offset = 0;
|
|
int mlen = (int)strlen("control:");
|
|
|
|
ctl_buf[0] = '\0';
|
|
|
|
HDRV * pHdr = (HDRV *)pps_lookup_start(&(rx_msg->sdp_ctx));
|
|
|
|
pHdr = rtsp_find_mdesc_point(rx_msg, pHdr, tname, &next_offset, attr);
|
|
if (pHdr == NULL)
|
|
{
|
|
pps_lookup_end(&(rx_msg->sdp_ctx));
|
|
return FALSE;
|
|
}
|
|
|
|
pHdr = (HDRV *)pps_lookup_next(&(rx_msg->sdp_ctx), pHdr);
|
|
while (pHdr != NULL)
|
|
{
|
|
if (strcasecmp(pHdr->header, "m") == 0)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (pHdr->value_string && pHdr->header[0] == 'a' && memcmp(pHdr->value_string, "control:", mlen) == 0)
|
|
{
|
|
int rlen = (int)strlen(pHdr->value_string) - mlen;
|
|
if (rlen > max_len)
|
|
{
|
|
rlen = max_len;
|
|
}
|
|
|
|
int offset = 0;
|
|
|
|
while (pHdr->value_string[offset+mlen] == ' ')
|
|
{
|
|
offset++;
|
|
}
|
|
|
|
strcpy(ctl_buf, pHdr->value_string+offset+mlen);
|
|
|
|
pps_lookup_end(&(rx_msg->sdp_ctx));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
pHdr = (HDRV *)pps_lookup_next(&(rx_msg->sdp_ctx), pHdr);
|
|
}
|
|
|
|
pps_lookup_end(&(rx_msg->sdp_ctx));
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
// a=range:npt=0-20.735
|
|
BOOL rtsp_get_sdp_range(HRTSP_MSG * rx_msg, int * p_start, int * p_end)
|
|
{
|
|
if (rx_msg == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
*p_start = 0;
|
|
*p_end = 0;
|
|
|
|
int mlen = (int)strlen("range:");
|
|
|
|
HDRV * pHdr = (HDRV *)pps_lookup_start(&(rx_msg->sdp_ctx));
|
|
pHdr = (HDRV *)pps_lookup_next(&(rx_msg->sdp_ctx), pHdr);
|
|
while (pHdr != NULL)
|
|
{
|
|
if (strcasecmp(pHdr->header, "m") == 0)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (pHdr->value_string && pHdr->header[0] == 'a' && memcmp(pHdr->value_string, "range:", mlen) == 0)
|
|
{
|
|
int i = 0;
|
|
int offset = 0;
|
|
int rlen = (int)strlen(pHdr->value_string) - mlen;
|
|
char start_buf[32] = {'\0'}, end_buf[32] = {'\0'};
|
|
char * p_buff = start_buf;
|
|
|
|
// skip space
|
|
while (pHdr->value_string[offset+mlen] == ' ')
|
|
{
|
|
offset++;
|
|
}
|
|
|
|
if (rlen < offset + 4)
|
|
{
|
|
pps_lookup_end(&(rx_msg->sdp_ctx));
|
|
return FALSE;
|
|
}
|
|
|
|
if (pHdr->value_string[offset+mlen] != 'n' &&
|
|
pHdr->value_string[offset+mlen+1] == 'p' &&
|
|
pHdr->value_string[offset+mlen+2] == 't')
|
|
{
|
|
pps_lookup_end(&(rx_msg->sdp_ctx));
|
|
return FALSE;
|
|
}
|
|
|
|
offset += 3; // skip "npt"
|
|
|
|
// skip space
|
|
while (pHdr->value_string[offset+mlen] == ' ')
|
|
{
|
|
offset++;
|
|
}
|
|
|
|
if (pHdr->value_string[offset+mlen] != '=')
|
|
{
|
|
pps_lookup_end(&(rx_msg->sdp_ctx));
|
|
return FALSE;
|
|
}
|
|
|
|
offset++; // skip '='
|
|
|
|
while (pHdr->value_string[offset+mlen] != '\0')
|
|
{
|
|
if (pHdr->value_string[offset+mlen] == '-')
|
|
{
|
|
i = 0;
|
|
p_buff = end_buf;
|
|
}
|
|
else if (pHdr->value_string[offset+mlen] != ' ')
|
|
{
|
|
p_buff[i++] = pHdr->value_string[offset+mlen];
|
|
|
|
if (i >= 32)
|
|
{
|
|
pps_lookup_end(&(rx_msg->sdp_ctx));
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
offset++;
|
|
}
|
|
|
|
*p_start = (int)(atof(start_buf) * 1000); // convert to millisecond
|
|
*p_end = (int)(atof(end_buf) * 1000);
|
|
|
|
break;
|
|
}
|
|
|
|
pHdr = (HDRV *)pps_lookup_next(&(rx_msg->sdp_ctx), pHdr);
|
|
}
|
|
pps_lookup_end(&(rx_msg->sdp_ctx));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL rtsp_is_support_mcast(HRTSP_MSG * rx_msg)
|
|
{
|
|
BOOL ret = FALSE;
|
|
|
|
HDRV * pHdr = (HDRV *)pps_lookup_start(&(rx_msg->sdp_ctx));
|
|
while (pHdr != NULL)
|
|
{
|
|
if (strcasecmp(pHdr->header, "m") == 0)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (strcasecmp(pHdr->header, "a") == 0)
|
|
{
|
|
if (strstr(pHdr->value_string, "type:broadcast"))
|
|
{
|
|
ret = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
pHdr = (HDRV *)pps_lookup_next(&(rx_msg->sdp_ctx), pHdr);
|
|
}
|
|
pps_lookup_end(&(rx_msg->sdp_ctx));
|
|
|
|
return ret;
|
|
}
|
|
|
|
BOOL rtsp_get_scale_info(HRTSP_MSG * rx_msg, int * p_scale)
|
|
{
|
|
if (rx_msg == NULL || p_scale == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
HDRV * rx_line = rtsp_find_headline(rx_msg, "Scale");
|
|
if (rx_line == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
char * ptr = rx_line->value_string;
|
|
|
|
while (*ptr == ' ' || *ptr == '\t')
|
|
{
|
|
ptr++;
|
|
}
|
|
|
|
double scale = strtod(ptr, NULL);
|
|
if (scale == 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
*p_scale = (int)(scale * 100);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL rtsp_get_rate_control(HRTSP_MSG * rx_msg, int * p_ratectrl)
|
|
{
|
|
if (rx_msg == NULL || p_ratectrl == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
HDRV * rx_line = rtsp_find_headline(rx_msg, "Rate-Control");
|
|
if (rx_line == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
char * ptr = rx_line->value_string;
|
|
|
|
while (*ptr == ' ' || *ptr == '\t')
|
|
{
|
|
ptr++;
|
|
}
|
|
|
|
int ratectrl = 1;
|
|
|
|
if (strcasecmp(ptr, "no") == 0)
|
|
{
|
|
ratectrl = 0;
|
|
}
|
|
|
|
*p_ratectrl = ratectrl;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL rtsp_get_immediate(HRTSP_MSG * rx_msg, int * p_imme)
|
|
{
|
|
if (rx_msg == NULL || p_imme == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
HDRV * rx_line = rtsp_find_headline(rx_msg, "Immediate");
|
|
if (rx_line == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
char * ptr = rx_line->value_string;
|
|
|
|
while (*ptr == ' ' || *ptr == '\t')
|
|
{
|
|
ptr++;
|
|
}
|
|
|
|
int imme = 0;
|
|
|
|
if (strcasecmp(ptr, "yes") == 0)
|
|
{
|
|
imme = 1;
|
|
}
|
|
|
|
*p_imme = imme;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL rtsp_get_frame_info(HRTSP_MSG * rx_msg, int * p_frame, int * p_interval)
|
|
{
|
|
if (rx_msg == NULL || p_frame == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
HDRV * rx_line = rtsp_find_headline(rx_msg, "Frames");
|
|
if (rx_line == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
char * ptr = rx_line->value_string;
|
|
|
|
while (*ptr == ' ' || *ptr == '\t')
|
|
{
|
|
ptr++;
|
|
}
|
|
|
|
int frame = 0; // all frames
|
|
|
|
if (strncasecmp(ptr, "intra", 5) == 0)
|
|
{
|
|
frame = 2; // I-frame
|
|
|
|
ptr += 5;
|
|
|
|
while (*ptr == ' ' || *ptr == '\t')
|
|
{
|
|
ptr++;
|
|
}
|
|
|
|
if (*ptr == '/')
|
|
{
|
|
ptr++;
|
|
|
|
if (p_interval)
|
|
{
|
|
*p_interval = atoi(ptr);
|
|
}
|
|
}
|
|
}
|
|
else if (strcasecmp(ptr, "predicted") == 0)
|
|
{
|
|
frame = 1; // I-frame and P-frame
|
|
}
|
|
|
|
*p_frame = frame;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*****************************************************************/
|
|
static PPSN_CTX * rtsp_msg_buf_fl = NULL;
|
|
static int rtsp_msg_buf_init_count = 0;
|
|
/*****************************************************************/
|
|
BOOL rtsp_msg_buf_init(int num)
|
|
{
|
|
rtsp_msg_buf_init_count++;
|
|
if (rtsp_msg_buf_fl)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
rtsp_msg_buf_fl = pps_ctx_fl_init(num, sizeof(HRTSP_MSG), TRUE);
|
|
if (rtsp_msg_buf_fl == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void rtsp_msg_buf_deinit()
|
|
{
|
|
rtsp_msg_buf_init_count--;
|
|
if (rtsp_msg_buf_init_count == 0) {
|
|
if (rtsp_msg_buf_fl)
|
|
{
|
|
pps_fl_free(rtsp_msg_buf_fl);
|
|
rtsp_msg_buf_fl = NULL;
|
|
}
|
|
}
|
|
if (rtsp_msg_buf_init_count < 0)rtsp_msg_buf_init_count = 0;
|
|
|
|
}
|
|
|
|
HRTSP_MSG * rtsp_get_msg_buf()
|
|
{
|
|
HRTSP_MSG * tx_msg = (HRTSP_MSG *)pps_fl_pop(rtsp_msg_buf_fl);
|
|
if (tx_msg == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
memset(tx_msg, 0, sizeof(HRTSP_MSG));
|
|
|
|
tx_msg->msg_buf = net_buf_get_idle();
|
|
if (tx_msg->msg_buf == NULL)
|
|
{
|
|
rtsp_free_msg_buf(tx_msg);
|
|
return NULL;
|
|
}
|
|
|
|
rtsp_msg_ctx_init(tx_msg);
|
|
|
|
return tx_msg;
|
|
}
|
|
|
|
void rtsp_msg_ctx_init(HRTSP_MSG * msg)
|
|
{
|
|
pps_ctx_ul_init_nm(hdrv_buf_fl, &(msg->rtsp_ctx));
|
|
pps_ctx_ul_init_nm(hdrv_buf_fl, &(msg->sdp_ctx));
|
|
}
|
|
|
|
void rtsp_free_msg_buf(HRTSP_MSG * msg)
|
|
{
|
|
pps_fl_push(rtsp_msg_buf_fl, msg);
|
|
}
|
|
|
|
uint32 rtsp_idle_msg_buf_num()
|
|
{
|
|
return rtsp_msg_buf_fl->node_num;
|
|
}
|
|
|
|
BOOL rtsp_parse_buf_init(int nums)
|
|
{
|
|
BOOL ret = rtsp_msg_buf_init(nums);
|
|
return ret;
|
|
}
|
|
|
|
void rtsp_parse_buf_deinit()
|
|
{
|
|
rtsp_msg_buf_deinit();
|
|
}
|
|
|
|
|
|
|