开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
rtsp_resp.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：19k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

rtsp_resp.c：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is MPEG4IP.
  13.  * 
  14.  * The Initial Developer of the Original Code is Cisco Systems Inc.
  15.  * Portions created by Cisco Systems Inc. are
  16.  * Copyright (C) Cisco Systems Inc. 2000, 2001.  All Rights Reserved.
  17.  * 
  18.  * Contributor(s): 
  19.  *              Bill May        wmay@cisco.com
  20.  */
  21. /*
  22.  * rtsp_resp.c - process rtsp response
  23.  */
  25. #include "rtsp_private.h"
  27. static const char *end2 = "nr";
  28. static const char *end1 = "rn";
  29. static const char *end3 = "r";
  30. static const char *end4 = "n";
  32. /*
  33.  * find_end_seperator()
  34.  * Will search through the string pointer to by ptr, and figure out
  35.  * what character is being used as a seperator - either r n, rn
  36.  * or nr.
  37.  *
  38.  * Inputs:
  39.  *    ptr - string to decode
  40.  *    len - pointer to end seperator len
  41.  *
  42.  * Outputs:
  43.  *    pointer to character to use as end seperator.  Dividing the len
  44.  *    by 2, and adding to the return pointer will give the normal
  45.  *    line seperator.
  46.  */
  47. static const char *find_seperator (const char *ptr)
  48. {
  49.   while (*ptr != '') {
  50.     if (*ptr == 'r') {
  51.       if (*(ptr + 1) == 'n') {
  52. return (end1);
  53.       } else {
  54. return (end3);
  55.       }
  56.     } else if (*ptr == 'n') {
  57.       if (*(ptr + 1) == 'r') {
  58. return (end2);
  59.       } else {
  60. return (end4);
  61.       }
  62.     }
  63.     ptr++;
  64.   }
  65.   return (NULL);
  66. }
  68. /************************************************************************
  69.  * Decode rtsp header lines.
  70.  *
  71.  * These routines will decode the various RTSP header lines, setting the
  72.  * correct information in the rtsp_decode_t structure.
  73.  *
  74.  * DEC_DUP_WARN macro will see if the field is already set, and send a warning
  75.  * if it is.  If the cont_line field is set, it will append the next line
  76.  *
  77.  ************************************************************************/
  78. #define RTSP_HEADER_FUNC(a) static void a (const char *lptr, rtsp_decode_t *dec, int cont_line)
  80. static void dec_dup_warn (char **location,
  81.   const char *lptr,
  82.   const char *warn,
  83.   int cont_line)
  84. {
  85.   if (*location == NULL) {
  86.     *location = strdup(lptr);
  87.   } else if (cont_line != 0) {
  88.     uint32_t len = strlen(*location);
  89.     len += strlen(lptr);
  90.     len++;
  91.     *location = realloc(*location, len);
  92.     strcat(*location, lptr);
  93.   } else {
  94.     rtsp_debug(LOG_WARNING, "2nd %s %s", warn, lptr);
  95.   }
  96. }
  98. #define DEC_DUP_WARN(a, b) dec_dup_warn(&dec->a, lptr, b, cont_line)
  100. RTSP_HEADER_FUNC(rtsp_header_allow_public)
  101. {
  102.   DEC_DUP_WARN(allow_public, "allow public");
  103. }
  105. RTSP_HEADER_FUNC(rtsp_header_connection)
  106. {
  107.   if (strncasecmp(lptr, "close", strlen("close")) == 0) {
  108.     dec->close_connection = TRUE;
  109.   }
  110. }
  112. RTSP_HEADER_FUNC(rtsp_header_cookie)
  113. {
  114.   DEC_DUP_WARN(cookie, "cookie");
  115. }
  117. RTSP_HEADER_FUNC(rtsp_header_content_base)
  118. {
  119.   DEC_DUP_WARN(content_base, "Content-Base");
  120. }
  122. RTSP_HEADER_FUNC(rtsp_header_content_length)
  123. {
  124.   dec->content_length = strtoul(lptr, NULL, 10);
  125. }
  127. RTSP_HEADER_FUNC(rtsp_header_content_loc)
  128. {
  129.   DEC_DUP_WARN(content_location, "Content-Location");
  130. }
  132. RTSP_HEADER_FUNC(rtsp_header_content_type)
  133. {
  134.   DEC_DUP_WARN(content_type, "Content-Type");
  135. }
  137. RTSP_HEADER_FUNC(rtsp_header_cseq)
  138. {
  139.   dec->cseq = strtoul(lptr, NULL, 10);
  140. }
  142. RTSP_HEADER_FUNC(rtsp_header_location)
  143. {
  144.   DEC_DUP_WARN(location, "Location");
  145. }
  147. RTSP_HEADER_FUNC(rtsp_header_range)
  148. {
  149.   DEC_DUP_WARN(range, "Range");
  150. }
  152. RTSP_HEADER_FUNC(rtsp_header_retry_after)
  153. {
  154.   // May try strptime if we need to convert
  155.   DEC_DUP_WARN(retry_after, "Retry-After");
  156. }
  158. RTSP_HEADER_FUNC(rtsp_header_rtp)
  159. {
  160.   DEC_DUP_WARN(rtp_info, "RtpInfo");
  161. }
  163. RTSP_HEADER_FUNC(rtsp_header_session)
  164. {
  165.   DEC_DUP_WARN(session, "Session");
  166. }
  168. RTSP_HEADER_FUNC(rtsp_header_speed)
  169. {
  170.   DEC_DUP_WARN(speed, "Speed");
  171. }
  173. RTSP_HEADER_FUNC(rtsp_header_transport)
  174. {
  175.   DEC_DUP_WARN(transport, "Transport");
  176. }
  178. RTSP_HEADER_FUNC(rtsp_header_www)
  179. {
  180.   DEC_DUP_WARN(www_authenticate, "WWW-Authenticate");
  181. }
  183. RTSP_HEADER_FUNC(rtsp_header_accept)
  184. {
  185.   DEC_DUP_WARN(accept, "Accept");
  186. }
  188. RTSP_HEADER_FUNC(rtsp_header_accept_enc)
  189. {
  190.   DEC_DUP_WARN(accept_encoding, "Accept-Encoding");
  191. }
  193. RTSP_HEADER_FUNC(rtsp_header_accept_lang)
  194. {
  195.   DEC_DUP_WARN(accept_language, "Accept-Language");
  196. }
  198. RTSP_HEADER_FUNC(rtsp_header_auth)
  199. {
  200.   DEC_DUP_WARN(authorization, "Authorization");
  201. }
  203. RTSP_HEADER_FUNC(rtsp_header_bandwidth)
  204. {
  205.   DEC_DUP_WARN(bandwidth, "Bandwidth");
  206. }
  208. RTSP_HEADER_FUNC(rtsp_header_blocksize)
  209. {
  210.   DEC_DUP_WARN(blocksize, "blocksize");
  211. }
  213. RTSP_HEADER_FUNC(rtsp_header_cache_control)
  214. {
  215.   DEC_DUP_WARN(cache_control, "Cache-control:");
  216. }
  218. RTSP_HEADER_FUNC(rtsp_header_content_enc)
  219. {
  220.   DEC_DUP_WARN(content_encoding, "Content-Encoding:");
  221. }
  223. RTSP_HEADER_FUNC(rtsp_header_content_lang)
  224. {
  225.   DEC_DUP_WARN(content_language, "Content-Language:");
  226. }
  227. RTSP_HEADER_FUNC(rtsp_header_date)
  228. {
  229.   DEC_DUP_WARN(date, "Date:");
  230. }
  232. RTSP_HEADER_FUNC(rtsp_header_expires)
  233. {
  234.   DEC_DUP_WARN(expires, "Expires:");
  235. }
  237. RTSP_HEADER_FUNC(rtsp_header_from)
  238. {
  239.   DEC_DUP_WARN(from, "From:");
  240. }
  242. RTSP_HEADER_FUNC(rtsp_header_ifmod)
  243. {
  244.   DEC_DUP_WARN(if_modified_since, "If-Modified-Since:");
  245. }
  247. RTSP_HEADER_FUNC(rtsp_header_lastmod)
  248. {
  249.   DEC_DUP_WARN(last_modified, "Last-Modified:");
  250. }
  252. RTSP_HEADER_FUNC(rtsp_header_proxyauth)
  253. {
  254.   DEC_DUP_WARN(proxy_authenticate, "Proxy-Authenticate:");
  255. }
  257. RTSP_HEADER_FUNC(rtsp_header_proxyreq)
  258. {
  259.   DEC_DUP_WARN(proxy_require, "Proxy-Require:");
  260. }
  262. RTSP_HEADER_FUNC(rtsp_header_referer)
  263. {
  264.   DEC_DUP_WARN(referer, "Referer:");
  265. }
  267. RTSP_HEADER_FUNC(rtsp_header_scale)
  268. {
  269.   DEC_DUP_WARN(scale, "Scale:");
  270. }
  272. RTSP_HEADER_FUNC(rtsp_header_server)
  273. {
  274.   DEC_DUP_WARN(server, "Server:");
  275. }
  277. RTSP_HEADER_FUNC(rtsp_header_unsup)
  278. {
  279.   DEC_DUP_WARN(unsupported, "Unsupported:");
  280. }
  282. RTSP_HEADER_FUNC(rtsp_header_uagent)
  283. {
  284.   DEC_DUP_WARN(user_agent, "User-Agent:");
  285. }
  287. RTSP_HEADER_FUNC(rtsp_header_via)
  288. {
  289.   DEC_DUP_WARN(via, "Via:");
  290. }
  292. /*
  293.  * header_types structure will provide a lookup between certain headers
  294.  * in RTSP, and the function routines (above) that deal with actions based
  295.  * on the response
  296.  */
  297. static struct {
  298.   const char *val;
  299.   uint32_t val_length;
  300.   void (*parse_routine)(const char *lptr, rtsp_decode_t *decode, int cont_line);
  301. } header_types[] =
  302. {
  303. #define HEAD_TYPE(a, b) { a, sizeof(a), b }
  304.   HEAD_TYPE("Allow:", rtsp_header_allow_public),
  305.   HEAD_TYPE("Public:", rtsp_header_allow_public),
  306.   HEAD_TYPE("Connection:", rtsp_header_connection),
  307.   HEAD_TYPE("Content-Base:", rtsp_header_content_base),
  308.   HEAD_TYPE("Content-Length:", rtsp_header_content_length),
  309.   HEAD_TYPE("Content-Location:", rtsp_header_content_loc),
  310.   HEAD_TYPE("Content-Type:", rtsp_header_content_type),
  311.   HEAD_TYPE("CSeq:", rtsp_header_cseq),
  312.   HEAD_TYPE("Location:", rtsp_header_location),
  313.   HEAD_TYPE("Range:", rtsp_header_range),
  314.   HEAD_TYPE("Retry-After:", rtsp_header_retry_after),
  315.   HEAD_TYPE("RTP-Info:", rtsp_header_rtp),
  316.   HEAD_TYPE("Session:", rtsp_header_session),
  317.   HEAD_TYPE("Set-Cookie:", rtsp_header_cookie),
  318.   HEAD_TYPE("Speed:", rtsp_header_speed),
  319.   HEAD_TYPE("Transport:", rtsp_header_transport),
  320.   HEAD_TYPE("WWW-Authenticate:", rtsp_header_www),
  321.   // None of these are needed for client, but are included for completion
  322.   HEAD_TYPE("Accept:", rtsp_header_accept),
  323.   HEAD_TYPE("Accept-Encoding:", rtsp_header_accept_enc),
  324.   HEAD_TYPE("Accept-Language:", rtsp_header_accept_lang),
  325.   HEAD_TYPE("Authorization:", rtsp_header_auth),
  326.   HEAD_TYPE("Bandwidth:", rtsp_header_bandwidth),
  327.   HEAD_TYPE("Blocksize:", rtsp_header_blocksize),
  328.   HEAD_TYPE("Cache-Control:", rtsp_header_cache_control),
  329.   HEAD_TYPE("Content-Encoding:", rtsp_header_content_enc),
  330.   HEAD_TYPE("Content-Language:", rtsp_header_content_lang),
  331.   HEAD_TYPE("Date:", rtsp_header_date),
  332.   HEAD_TYPE("Expires:", rtsp_header_expires),
  333.   HEAD_TYPE("From:", rtsp_header_from),
  334.   HEAD_TYPE("If-Modified-Since:", rtsp_header_ifmod),
  335.   HEAD_TYPE("Last-Modified:", rtsp_header_lastmod),
  336.   HEAD_TYPE("Proxy-Authenticate:", rtsp_header_proxyauth),
  337.   HEAD_TYPE("Proxy-Require:", rtsp_header_proxyreq),
  338.   HEAD_TYPE("Referer:", rtsp_header_referer),
  339.   HEAD_TYPE("Scale:", rtsp_header_scale),
  340.   HEAD_TYPE("Server:", rtsp_header_server),
  341.   HEAD_TYPE("Unsupported:", rtsp_header_unsup),
  342.   HEAD_TYPE("User-Agent:", rtsp_header_uagent),
  343.   HEAD_TYPE("Via:", rtsp_header_via),
  344.   { NULL, 0, NULL },
  345. };
  347. // We don't care about the following: Cache-control, date, expires,
  348. // Last-modified, Server, Unsupported, Via
  350. /*
  351.  * rtsp_decode_header - header line pointed to by lptr.  will be  terminated
  352.  * Decode using above table
  353.  */
  354. static void rtsp_decode_header (const char *lptr,
  355. rtsp_client_t *info,
  356. int *last_number)
  357. {
  358.   int ix;
  359.   const char *after;
  361.   ix = 0;
  362.   /*
  363.    * go through above array, looking for a complete match
  364.    */
  365.   while (header_types[ix].val != NULL) {
  366.     if (strncasecmp(lptr,
  367.     header_types[ix].val,
  368.     header_types[ix].val_length - 1) == 0) {
  369.       after = lptr + header_types[ix].val_length;
  371.       ADV_SPACE(after);
  372.       /*
  373.        * Call the correct parsing routine
  374.        */
  375.       (header_types[ix].parse_routine)(after, info->decode_response, 0);
  376.       *last_number = ix;
  377.       return;
  378.     }
  379.     ix++;
  380.   }
  382.   if (last_number >= 0 && isspace(*lptr)) {
  383.     //asdf
  384.     ADV_SPACE(lptr);
  385.     (header_types[*last_number].parse_routine)(lptr, info->decode_response, 1);
  386.   } else 
  387.     rtsp_debug(LOG_DEBUG, "Not processing response header: %s", lptr);
  388. }
  389. static int rtsp_read_into_buffer (rtsp_client_t *cptr,
  390.   uint32_t buffer_offset,
  391.   int wait)
  392. {
  393.   int ret;
  395.   ret = rtsp_receive_socket(cptr,
  396.     cptr->m_resp_buffer + buffer_offset,
  397.     RECV_BUFF_DEFAULT_LEN - buffer_offset,
  398.     cptr->recv_timeout, 
  399.     wait);
  401.   if (ret <= 0) return (ret);
  403.   cptr->m_buffer_len = buffer_offset + ret;
  404.   cptr->m_resp_buffer[cptr->m_buffer_len] = '';
  406.   return ret;
  407. }
  409. int rtsp_bytes_in_buffer (rtsp_client_t *cptr)
  410. {
  411.   return (cptr->m_buffer_len - cptr->m_offset_on);
  412. }
  414. int rtsp_recv (rtsp_client_t *cptr,
  415.        char *buffer,
  416.        uint32_t len)
  417. {
  418.   uint32_t mlen;
  419.   int copied, result;
  421.   copied = 0;
  422.   if (cptr->m_offset_on < cptr->m_buffer_len) {
  423.     mlen =  MIN(len, cptr->m_buffer_len - cptr->m_offset_on);
  424.     memmove(buffer,
  425.     &cptr->m_resp_buffer[cptr->m_offset_on],
  426.     mlen);
  427.     cptr->m_offset_on += mlen;
  428.     len -= mlen;
  429.     copied += mlen;
  430.   }
  431.   if (len > 0) {
  432.     result = rtsp_receive_socket(cptr,
  433.  buffer + copied,
  434.  len,
  435.  0,
  436.  0);
  437.     if (result >= 0) {
  438.       copied += result;
  439.     }
  440.   }
  441.   return copied;
  442. }
  443.     
  444.     
  445. static int rtsp_save_and_read (rtsp_client_t *cptr)
  446. {
  447.   int last_on;
  448.   int ret;
  449.   cptr->m_buffer_len -= cptr->m_offset_on;
  450.   if (cptr->m_buffer_len >= RECV_BUFF_DEFAULT_LEN) {
  451.     return 0;
  452.   } else if (cptr->m_buffer_len != 0) {
  453.     memmove(cptr->m_resp_buffer,
  454.     &cptr->m_resp_buffer[cptr->m_offset_on],
  455.     cptr->m_buffer_len);
  456.     last_on = cptr->m_buffer_len;
  457.   } else {
  458.     last_on = 0;
  459.   }
  460.   
  461.   cptr->m_offset_on = 0;  
  462.   ret = rtsp_read_into_buffer(cptr, cptr->m_buffer_len, 0);
  463.   if (ret > 0) {
  464.     last_on += ret;
  465.   }
  466.   return (last_on);
  467. }
  469. static const char *rtsp_get_next_line (rtsp_client_t *cptr,
  470.        const char *seperator)
  471. {
  472.   int ret;
  473.   int last_on;
  474.   char *sep;
  476.   /*
  477.    * If we don't have any data, try to read a buffer full
  478.    */
  479.   if (cptr->m_buffer_len <= 0) {
  480.     cptr->m_offset_on = 0;
  481.     ret = rtsp_read_into_buffer(cptr, 0, 1);
  482.     if (ret <= 0) {
  483.       return (NULL);
  484.     }
  485.   }
  487.   /*
  488.    * Look for CR/LF in the buffer.  If we find it, NULL terminate at
  489.    * the CR, then set the buffer values to look past the crlf
  490.    */
  491.   sep = strstr(&cptr->m_resp_buffer[cptr->m_offset_on],
  492.        seperator);
  493.   if (sep != NULL) {
  494.     const char *retval = &cptr->m_resp_buffer[cptr->m_offset_on];
  495.     cptr->m_offset_on = sep - cptr->m_resp_buffer;
  496.     cptr->m_offset_on += strlen(seperator);
  497.     *sep = '';
  498.     return (retval);
  499.   }
  501.   if (cptr->m_offset_on == 0) {
  502.     return (NULL);
  503.   }
  505.   /*
  506.    * We don't have a line.  So, move the data down in the buffer, then
  507.    * read into the rest of the buffer
  508.    */
  509.   last_on = rtsp_save_and_read(cptr);
  510.   if (last_on < 0) return (NULL);
  511.   /*
  512.    * Continue searching through the buffer.  If we get this far, we've
  513.    * received like 2K or 4K without a CRLF - most likely a bad response
  514.    */
  515.   sep = strstr(&cptr->m_resp_buffer[last_on],
  516.        seperator);
  517.   if (sep != NULL) {
  518.     const char *retval = &cptr->m_resp_buffer[cptr->m_offset_on];
  519.     cptr->m_offset_on = sep - cptr->m_resp_buffer;
  520.     cptr->m_offset_on += strlen(seperator);
  521.     *sep = '';
  522.     return (retval);
  523.   }
  524.   return (NULL);
  525. }
  526. /*
  527.  * rtsp_parse_response - parse out response headers lines.  Figure out
  528.  * where seperators are, then use them to determine where the body is
  529.  */
  530. static int rtsp_parse_response (rtsp_client_t *info)
  531. {
  532.   const char *seperator;
  533.   const char *lptr, *p;
  534.   rtsp_decode_t *decode;
  535.   int ret, done;
  536.   int last_header = -1;
  537.   uint32_t len;
  539.   decode = info->decode_response;
  540.   
  541.   // Figure out what seperator is being used throughout the response
  542.   ret = rtsp_save_and_read(info);
  543.   if (ret < 0) {
  544.     return (RTSP_RESPONSE_RECV_ERROR);
  545.   }
  547.   seperator = find_seperator(info->m_resp_buffer);
  548.   if (seperator == NULL) {
  549.     rtsp_debug(LOG_INFO, "Could not find seperator in header");
  550.     return RTSP_RESPONSE_MALFORM_HEADER;
  551.   }
  552.   
  553.   //rtsp_debug(LOG_DEBUG, "Response buffer:n%s", info->m_resp_buffer);
  555.   do {
  556.     lptr = rtsp_get_next_line(info, seperator);
  557.     if (lptr == NULL) {
  558.       rtsp_debug(LOG_INFO, "Couldn't get next line");
  559.       return (RTSP_RESPONSE_MALFORM_HEADER);
  560.     }
  561.   } while (*lptr == '');
  563.   rtsp_debug(LOG_DEBUG, lptr);
  564.   if (strncasecmp(lptr, "RTSP/1.0", strlen("RTSP/1.0")) != 0) {
  565.     rtsp_debug(LOG_INFO, "RTSP/1.0 not found");
  566.     return RTSP_RESPONSE_MALFORM_HEADER;
  567.   }
  568.   p = lptr + strlen("RTSP/1.0");
  569.   ADV_SPACE(p);
  570.   memcpy(decode->retcode, p, 3);
  571.   decode->retcode[3] = '';
  573.   switch (*p) {
  574.   case '1':
  575.   case '2':
  576.   case '3':
  577.   case '4':
  578.   case '5':
  579.     break;
  580.   default:
  581.     rtsp_debug(LOG_INFO, "Bad error code %s", p);
  582.     return RTSP_RESPONSE_MALFORM_HEADER;
  583.   }
  584.   p += 3;
  585.   ADV_SPACE(p);
  586.   if (p != '') {
  587.     decode->retresp = strdup(p);
  588.   }
  589.   rtsp_debug(LOG_DEBUG, "Decoded status - code %s %s",
  590.      decode->retcode, decode->retresp);
  591.   done = 0;
  592.   do {
  593.     lptr = rtsp_get_next_line(info, seperator);
  595.     if (lptr == NULL) {
  596.       return (RTSP_RESPONSE_MALFORM_HEADER);
  597.     }
  598.     if (*lptr == '') {
  599.       done = 1;
  600.     } else {
  601.       rtsp_debug(LOG_DEBUG, lptr);
  602.       rtsp_decode_header(lptr, info, &last_header);
  603.     }
  604.   } while (done == 0);
  606.   if (decode->content_length != 0) {
  607.     rtsp_debug(LOG_DEBUG, "reading content length %d", decode->content_length);
  608.     decode->body = malloc(decode->content_length + 1);
  609.     decode->body[decode->content_length] = '';
  610.     len = info->m_buffer_len - info->m_offset_on;
  611.     rtsp_debug(LOG_DEBUG, "Copied %d bytes from buffer", len);
  612.     if (len < decode->content_length) {
  613.       // not enough in memory - need to read
  614.       memcpy(decode->body,
  615.      &info->m_resp_buffer[info->m_offset_on],
  616.      len);
  617.       while (len < decode->content_length) {
  618. int left;
  619. ret = rtsp_read_into_buffer(info, 0, 1);
  621. if (ret <= 0) {
  622.   rtsp_debug(LOG_DEBUG, "Returned from rtsp_read_into_buffer - error %d", 
  623.      ret);
  624.   return (-1);
  625. }
  626. left = decode->content_length - len;
  627. if (left < info->m_buffer_len) {
  628.   // we have more data in the buffer then we need
  629.   memcpy(decode->body + len,
  630.  info->m_resp_buffer,
  631.  left);
  632.   len += left;
  633.   info->m_offset_on = left;
  634. } else {
  635.   // exact or less - we're cool
  636.   memcpy(decode->body + len,
  637.  info->m_resp_buffer,
  638.  info->m_buffer_len);
  639.   len += info->m_buffer_len;
  640.   info->m_offset_on = info->m_buffer_len; // get ready for next...
  641. }
  642.       }
  643.     } else {
  644.       // Plenty in memory - copy it, continue to end...
  645.       memcpy(decode->body,
  646.      &info->m_resp_buffer[info->m_offset_on],
  647.      decode->content_length);
  648.       info->m_offset_on += decode->content_length;
  649.     }
  650.   } else if (decode->close_connection) {
  651.     // No termination - just deal with what we've got...
  652.     len = info->m_buffer_len - info->m_offset_on;
  653.     decode->body = (char *)malloc(len + 1);
  654.     memcpy(decode->body,
  655.    &info->m_resp_buffer[info->m_offset_on],
  656.    len);
  657.     decode->body[len] = '';
  658.   }
  659.   if (decode->body != NULL)
  660.      rtsp_debug(LOG_DEBUG, "%s", decode->body);
  661.   return (0);
  662. }
  664. /*
  665.  * rtsp_get_response - wait for a complete response.  Interesting that
  666.  * it could be in multiple packets, so deal with that.
  667.  */
  668. int rtsp_get_response (rtsp_client_t *info)
  669. {
  670.   int ret;
  671.   rtsp_decode_t *decode;
  672.   int response_okay;
  674.   while (1) {
  675.     // In case we didn't get a response that we wanted.
  676.     if (info->decode_response != NULL) {
  677.       clear_decode_response(info->decode_response);
  678.       decode = info->decode_response;
  679.     } else {
  680.       decode = info->decode_response = malloc(sizeof(rtsp_decode_t));
  681.       if (decode == NULL) {
  682. rtsp_debug(LOG_ALERT, "Couldn't create decode response");
  683. return (RTSP_RESPONSE_RECV_ERROR);
  684.       }
  685.     }
  686.     
  687.     memset(decode, 0, sizeof(rtsp_decode_t));
  689.     do {
  690.       // Parse response.
  691.       ret = rtsp_parse_response(info);
  692.       rtsp_debug(LOG_DEBUG, "parsed response - len %d offset %d",
  693.  info->m_buffer_len, info->m_offset_on);
  694.       if (ret != 0) {
  695. if (info->thread == NULL)
  696.   rtsp_close_socket(info);
  697. rtsp_debug(LOG_ERR, "return code %d from rtsp_parse_response", ret);
  698. return (RTSP_RESPONSE_RECV_ERROR);
  699.       }
  701.       if (decode->close_connection) {
  702. rtsp_debug(LOG_DEBUG, "Response requested connection close");
  703. rtsp_close_socket(info);
  704.       }
  705.   
  706.       response_okay = TRUE;
  707.       // Okay - we have a good response. - check the cseq, and return
  708.       // the correct error code.
  709.       if (info->next_cseq == decode->cseq) {
  710. info->next_cseq++;
  711. if ((decode->retcode[0] == '4') ||
  712.     (decode->retcode[0] == '5')) {
  713.   return (RTSP_RESPONSE_BAD);
  714. }
  715. if (decode->cookie != NULL) {
  716.   // move cookie to rtsp_client
  717.   info->cookie = strdup(decode->cookie);
  718. }
  719. if (decode->retcode[0] == '2') {
  720.   return (RTSP_RESPONSE_GOOD);
  721. }
  722. if (decode->retcode[0] == '3') {
  723.   if (decode->location == NULL) {
  724.     return (RTSP_RESPONSE_BAD);
  725.   }
  726.   if (rtsp_setup_redirect(info) != 0) {
  727.     return (RTSP_RESPONSE_BAD);
  728.   }
  729.   return (RTSP_RESPONSE_REDIRECT);
  730. }
  731.       }
  732. #if 0
  733.       if (info->m_buffer_len != 0) {
  734. // We have more in the buffer - see if it's what
  735. // we need
  736. // clear out last response
  737. clear_decode_response(decode);
  738. memset(decode, 0, sizeof(rtsp_decode_t));
  739.       }
  740. #endif
  741.     } while (info->m_buffer_len != 0);
  742.   } 
  743.   return (RTSP_RESPONSE_RECV_ERROR);
  744. }
  746. /* end file rtsp_resp.c */