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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

sdp_decode.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.  * sdp_decode.c
  23.  *
  24.  * decode SDP format from file into session description structures
  25.  * defined in sdp.h
  26.  *
  27.  * October, 2000
  28.  * Bill May (wmay@cisco.com)
  29.  * Cisco Systems, Inc.
  30.  */
  31. #include "sdp.h"
  32. #include "sdp_decode_private.h"
  34. #define ADV_SPACE(a) {while (isspace(*(a)) && (*(a) != ''))(a)++;}
  36. static const char *SPACES=" t";
  38. #define FREE_CHECK(a,b) if (a->b != NULL) { free(a->b); a->b = NULL;}
  40. /*****************************************************************************
  41.  * Memory free routines - frees memory associated with various structures
  42.  *****************************************************************************/
  44. static void free_bandwidth_desc (bandwidth_t *bptr)
  45. {
  46.   bandwidth_t *q;
  47.   while (bptr != NULL) {
  48.     q = bptr;
  49.     bptr = q->next;
  50.     FREE_CHECK(q, user_band);
  51.     free(q);
  52.   }
  53. }
  55. static void free_category_list (category_list_t **cptr)
  56. {
  57.   category_list_t *p;
  58.   if (*cptr == NULL) return;
  59.   
  60.   while (*cptr != NULL) {
  61.     p = *cptr;
  62.     *cptr = p->next;
  63.     free(p);
  64.   }
  65. }
  67. static void free_connect_desc (connect_desc_t *cptr)
  68. {
  69.   FREE_CHECK(cptr, conn_type);
  70.   FREE_CHECK(cptr, conn_addr);
  71. }
  73. /*
  74.  * free_media_desc()
  75.  * Frees all memory associated with a media descriptor(mptr)
  76.  */
  77. static void free_media_desc (media_desc_t *mptr)
  78. {
  79.   free_bandwidth_desc(mptr->media_bandwidth);
  80.   mptr->media_bandwidth = NULL;
  81.   free_connect_desc(&mptr->media_connect);
  82.   sdp_free_format_list(&mptr->fmt);
  83.   sdp_free_string_list(&mptr->unparsed_a_lines);
  84.   FREE_CHECK(mptr, media);
  85.   FREE_CHECK(mptr, media_desc);
  86.   FREE_CHECK(mptr, proto);
  87.   FREE_CHECK(mptr, sdplang);
  88.   FREE_CHECK(mptr, lang);
  89.   FREE_CHECK(mptr, orient_user_type);
  90.   FREE_CHECK(mptr, control_string);
  91.   FREE_CHECK(mptr, key.key);
  92.   mptr->parent = NULL;
  93.   free(mptr);
  94. }
  96. static void free_time_desc (session_time_desc_t *time)
  97. {
  98.   time_repeat_desc_t *rptr;
  99.   
  100.   if (time->next != NULL) {
  101.     free_time_desc(time->next);
  102.     time->next = NULL;
  103.   }
  104.   while (time->repeat != NULL) {
  105.     rptr = time->repeat;
  106.     time->repeat = rptr->next;
  107.     free (rptr);
  108.   }
  110.   free(time);
  111. }
  113. /*
  114.  * sdp_free_session_desc()
  115.  * Inputs - sptr - pointer to session_description list to free
  116.  */
  117. void sdp_free_session_desc (session_desc_t *sptr)
  118. {
  119.   session_desc_t *p;
  120.   media_desc_t *mptr, *q;
  122.   p = sptr;
  123.   while (p != NULL) {
  124.     sptr = p;
  125.     p = p->next;
  126.     
  127.     sptr->next = NULL;
  128.     mptr = sptr->media;
  129.     sptr->media = NULL;
  131.     while (mptr != NULL) {
  132.       q = mptr;
  133.       mptr = q->next;
  134.       free_media_desc(q);
  135.     }
  137.     FREE_CHECK(sptr, etag);
  138.     FREE_CHECK(sptr, orig_username);
  139.     FREE_CHECK(sptr, control_string);
  140.     FREE_CHECK(sptr, create_addr_type);
  141.     FREE_CHECK(sptr, create_addr);
  142.     FREE_CHECK(sptr, session_name);
  143.     FREE_CHECK(sptr, session_desc);
  144.     FREE_CHECK(sptr, uri);
  145.     FREE_CHECK(sptr, key.key);
  146.     FREE_CHECK(sptr, keywds);
  147.     FREE_CHECK(sptr, lang);
  148.     FREE_CHECK(sptr, tool);
  149.     FREE_CHECK(sptr, charset);
  150.     FREE_CHECK(sptr, sdplang);
  151.     FREE_CHECK(sptr, conf_type_user);
  153.     if (sptr->time_desc != NULL) {
  154.       free_time_desc(sptr->time_desc);
  155.       sptr->time_desc = NULL;
  156.     }
  158.     free_bandwidth_desc(sptr->session_bandwidth);
  159.     sptr->session_bandwidth = NULL;
  160.     free_category_list(&sptr->category_list);
  161.     free_connect_desc(&sptr->session_connect);
  162.     sdp_free_string_list(&sptr->admin_phone);
  163.     sdp_free_string_list(&sptr->admin_email);
  164.     sdp_free_string_list(&sptr->unparsed_a_lines);
  165.     
  166.     while (sptr->time_adj_desc != NULL) {
  167.       time_adj_desc_t *aptr;
  168.       aptr = sptr->time_adj_desc;
  169.       sptr->time_adj_desc = aptr->next;
  170.       free(aptr);
  171.     }
  172.   
  173.     free(sptr);
  174.   }
  175. }
  177. /*****************************************************************************
  178.  * Utility routines - string manipulation, etc
  179.  *****************************************************************************/
  180. /*
  181.  * get_next_line will get the next line to process, and stick it in
  182.  * lptr.
  183.  *
  184.  * Inputs:
  185.  *    lptr - buffer to store into
  186.  *    decode - pointer to where to get next line
  187.  *    buflen - max length of buffer
  188.  *
  189.  * Outputs:
  190.  *    TRUE - have a new line.
  191.  *    FALSE - all done.
  192.  */
  193. static int get_next_line (char **polptr,
  194.   sdp_decode_info_t *decode,
  195.   uint32_t *buflen)
  196. {
  197.   char *fret;
  198.   uint32_t len;
  199.   uint32_t buflen_left;
  200.   const char *cptr;
  202.   if (decode->isMem) {
  203.     cptr = decode->memptr;
  205.     if (*cptr == '') return FALSE;
  207.     while (*cptr != '' && *cptr != 'n' && *cptr != 'r') cptr++;
  209.     len = cptr - decode->memptr;
  210.     if (*buflen <= len + 1) {
  211.       if (len > 65535) {
  212. sdp_debug(LOG_CRIT, "Max line length of 65535 exceeded %u", 
  213.   len);
  214. return (FALSE);
  215.       }
  216.       *polptr = realloc(*polptr, len + 1);
  217.       *buflen = len + 1;
  218.     }
  219.     memcpy(*polptr, decode->memptr, len);
  220.     (*polptr)[len] = '';
  221.     decode->memptr += len;
  222.     while (*decode->memptr == 'n' || *decode->memptr == 'r')
  223.       decode->memptr++;
  224.   } else {
  225.     char *ptr;
  226.     // File reads...
  227.     if (decode->ifile == NULL)
  228.       return FALSE;
  229.     if (*buflen == 0) {
  230.       *polptr = (char *)malloc(1024);
  231.       *buflen = 1024;
  232.     }
  234.     // Read file until we hit the end, or a non-blank line read
  235.     ptr = *polptr;
  236.     buflen_left = *buflen;
  237.     len = 0;
  239.     while (1) {
  240.       fret = fgets(ptr, buflen_left, decode->ifile);
  241.       if (fret == NULL) {
  242. if (len > 0) {
  243.   sdp_debug(LOG_WARNING, "Unterminated last line");
  244.   (*polptr)[len] = ''; // make sure
  245.   return (TRUE);
  246. }
  247. return (FALSE);
  248.       }
  250.       len = strlen(ptr);
  251.       if (ptr[len - 1] == 'n' || ptr[len - 1] == 'r') {
  252. // we have an end of line
  253. len--;
  254. while (len >= 0 &&
  255.        (ptr[len] == 'n' || ptr[len] == 'r')) {
  256.   ptr[len] = '';
  257.   len--;
  258. }
  259. return (TRUE);
  260.       }
  261.       
  262.       // too long...
  263.       buflen_left -= len;
  264.       if (*buflen + 1024 > 65535) {
  265. sdp_debug(LOG_CRIT, "Max line length of 65535 exceeded %u", 
  266.   *buflen);
  267. return (FALSE);
  268.       }
  269.       *buflen += 1024;
  270.       buflen_left += 1024;
  271.       *polptr = realloc(*polptr, *buflen);
  272.       ptr = *polptr + *buflen - buflen_left;
  273.     }
  274.   }
  276.   return TRUE;
  277. }
  279. /*
  280.  * strtou64()
  281.  * Converts string to uint64_t number up to next space, with error checking.
  282.  * Inputs:
  283.  *    lptr - pointer to pointer to string.  *lptr will be modified
  284.  *    num - return value
  285.  * Outputs - TRUE - sucess, FALSE, failure
  286.  */
  287. static int strtou64 (char **lptr, uint64_t *num)
  288. {
  289.   char *sep;
  290.   
  291.   *num = 0;
  292.   ADV_SPACE((*lptr));
  293.   sep = strsep(lptr, SPACES);
  294.   if (sep == NULL || *lptr == NULL) {
  295.     return (FALSE);
  296.   }
  297.   *num = 0;
  298.   while (*sep != '') {
  299.     if (isdigit(*sep)) {
  300.       *num *= 10;
  301.       *num += *sep - '0';
  302.       sep++;
  303.     } else {
  304.       return (FALSE);
  305.     }
  306.   }
  307.   return (TRUE);
  308. }
  310. /*
  311.  * str_to_time_offset()
  312.  * converts typed-time field (number or [#d][#h][#m][#s])
  313.  *
  314.  * Inputs -
  315.  *   str -  terminated string to translate
  316.  *   retval - pointer to return value
  317.  * Returns -
  318.  *   TRUE - valid string processed;
  319.  *   FALSE - invalid string
  320.  */
  321. static int str_to_time_offset (const char *str, uint32_t *retval)
  322. {
  323.   uint32_t value;
  324.   uint32_t accum;
  325.   char temp;
  326.   
  327.   value = 0;
  328.   accum = 0;
  330.   if (!isdigit(*str)) return (FALSE);
  331.   
  332.   while (*str != '') {
  333.     if (isdigit(*str)) {
  334.       accum *= 10;
  335.       accum += (*str - '0');
  336.     } else {
  337.       temp = tolower(*str);
  338.       if (temp == 'd') {
  339. value += accum * SEC_PER_DAY;
  340. accum = 0;
  341.       } else if (temp == 'h') {
  342. value += accum * SEC_PER_HOUR;
  343. accum = 0;
  344.       } else if (temp == 'm') {
  345. value += accum * SEC_PER_MINUTE;
  346. accum = 0;
  347.       } else if (temp == 's') {
  348. value += accum;
  349. accum = 0;
  350.       } else {
  351. sdp_debug(LOG_ERR, "Illegal character %c in time offset", temp);
  352. return (FALSE);
  353.       }
  354.     }
  355.     str++;
  356.   }
  357.   value += accum;
  358.   *retval = value;
  359.   return (TRUE);
  360. }
  362. /*
  363.  * time_adj_order_in_list()
  364.  * order linked list by adj_time values.  We don't allow 2 items in the
  365.  * list - "new" value might be free'd at end
  366.  * Inputs:
  367.  *   start - pointer to start of list
  368.  *   new - pointer to new value
  369.  * Returns:
  370.  *   pointer to head of list - new value might be free'd.
  371.  */
  372. static time_adj_desc_t *time_adj_order_in_list (time_adj_desc_t *start,
  373. time_adj_desc_t *new)
  374. {
  375.   time_adj_desc_t *p, *q;
  376.   if (start == NULL)
  377.     return (new);
  379.   p = start;
  380.   q = NULL;
  381.   while (p != NULL) {
  382.     if (new->adj_time == p->adj_time) {
  383.       sdp_debug(LOG_NOTICE, "Duplicate time %ld in adj description", p->adj_time);
  384.       free(new);
  385.       return (start);
  386.     }
  387.     if (new->adj_time < p->adj_time) {
  388.       new->next = p;
  389.       if (q == NULL) {
  390. return (new);
  391.       } else {
  392. q->next = new;
  393. return (start);
  394.       }
  395.     }
  396.     q = p;
  397.     p = p->next;
  398.   }
  399.   q->next = new;
  400.   return (start);
  401. }
  404. /*****************************************************************************
  405.  * Line parsing routines
  406.  *****************************************************************************/
  407. /*
  408.  * sdp_decode_parse_a_bool()
  409.  * parses a boolean field.
  410.  */
  411. static int sdp_decode_parse_a_bool (int arg,
  412.     char *lptr,
  413.     session_desc_t *sptr,
  414.     media_desc_t *mptr)
  415. {
  416.   switch (arg) {
  417.   case 0:
  418.     if (mptr != NULL) mptr->recvonly = TRUE;
  419.     else sptr->recvonly = TRUE;
  420.     break;
  421.   case 1:
  422.     if (mptr != NULL) mptr->sendrecv = TRUE;
  423.     else sptr->sendrecv = TRUE;
  424.     break;
  425.   case 2:
  426.     if (mptr != NULL) mptr->sendonly = TRUE;
  427.     else sptr->sendonly = TRUE;
  428.     break;
  430.   }
  431.   return (0);
  432. }
  434. /*
  435.  * sdp_decode_parse_a_rtpmap()
  436.  * parses a=rtpmap:<fmt> <name>/<clockrate>[/<enc_param>]
  437.  */
  438. static int sdp_decode_parse_a_fmtp (int arg,
  439.     char *lptr,
  440.     session_desc_t *sptr,
  441.     media_desc_t *mptr)
  442. {
  443.   format_list_t *fptr;
  444.   int len;
  445.   
  446.   if (mptr == NULL)
  447.     return (-1);
  449.   /*
  450.    * See our format matches a value in the media's format list.
  451.    */
  452.   fptr = sdp_find_format_in_line(mptr->fmt,lptr) ;
  454.   if (fptr == NULL) {
  455.     sdp_debug(LOG_ALERT, "Can't find fmtp format %s in media format list", lptr);
  456.     return (-1);
  457.   }
  459.   len = strlen(fptr->fmt);
  460.   lptr += len;
  461.   lptr++;
  462.   ADV_SPACE(lptr);
  463.   fptr->fmt_param = strdup(lptr);
  464.   if (fptr->fmt_param == NULL) {
  465.     return (-1);
  466.   }
  467.   return (0);
  468. }
  470. /*
  471.  * sdp_decode_parse_a_rtpmap()
  472.  * parses a=rtpmap:<fmt> <name>/<clockrate>[/<enc_param>]
  473.  */
  474. static int sdp_decode_parse_a_rtpmap (int arg,
  475.       char *lptr,
  476.       session_desc_t *sptr,
  477.       media_desc_t *mptr)
  478. {
  479.   char *enc, *slash, *temp;
  480.   format_list_t *fptr;
  481.   int len;
  482.   uint32_t a, b;
  483.   
  484.   if (mptr == NULL)
  485.     return (-1);
  487.   /*
  488.    * See our format matches a value in the media's format list.
  489.    */
  490.   fptr = sdp_find_format_in_line(mptr->fmt,lptr) ;
  492.   if (fptr == NULL) {
  493.     sdp_debug(LOG_ALERT, "Can't find rtpmap format %s in media list", lptr);
  494.     return (-1);
  495.   }
  497.   len = strlen(fptr->fmt);
  498.   /*
  499.    * Matches entry left in fptr.  Decode rest of line
  500.    */
  501.   enc = lptr + len;
  502.   ADV_SPACE(enc);
  503.   slash = strchr(enc, '/');  
  504.   if (slash == NULL) {
  505.     sdp_debug(LOG_ERR, "Couldn't find / in rtpmap");
  506.     return (-1);
  507.   }
  509.   *slash++ = '';
  510.   temp = enc;
  511.   while ((!(isspace(*temp))) && *temp != '') temp++;
  512.   *temp = '';
  513.   
  514.   // enc points to encode name
  515.   ADV_SPACE(slash);
  516.   temp = strsep(&slash, " t/");
  517.   if (temp == NULL) {
  518.     sdp_debug(LOG_ERR, "Can't find seperator after encode name in rtpmap");
  519.     return (-1);
  520.   }
  522.   if (sscanf(temp, "%u", &a) == 0) {
  523.     sdp_debug(LOG_ERR, "Couldn't decode rtp clockrate %s", temp);
  524.     return (-1);
  525.   }
  527.   b = 0;
  528.   if (slash != NULL) {
  529.     ADV_SPACE(slash);
  530.     if (*slash == '/') {
  531.       slash++;
  532.       ADV_SPACE(slash);
  533.     }
  534.     if (isdigit(*slash)) {
  535.       sscanf(slash, "%u", &b);
  536.     }
  537.   }
  538.   
  539.   fptr->rtpmap = malloc(sizeof(rtpmap_desc_t));
  540.   if (fptr->rtpmap == NULL)
  541.     return (-1);
  542.   fptr->rtpmap->encode_name = strdup(enc);
  543.   fptr->rtpmap->clock_rate = a;
  544.   fptr->rtpmap->encode_param = b;
  545.   
  546.   return (0);
  547. }
  549. /*
  550.  * sdp_decode_parse_a_cat()
  551.  * parses a=category:foo.bar...
  552.  */
  553. static int sdp_decode_parse_a_cat (int arg,
  554.    char *orig_line,
  555.    session_desc_t *sptr,
  556.    media_desc_t *mptr)
  557. {
  558.   char *sep, *line, *lptr;
  559.   int errret;
  560.   uint64_t cat;
  561.   category_list_t *cptr, *new;
  562.   
  563.   if (sptr->category_list != NULL) {
  564.     return (-1);
  565.   }
  566.   errret = 0;
  567.   cptr = NULL; // shut up compiler
  568.   line = strdup(orig_line);
  569.   lptr = line;
  570.   while ((sep = strsep(&lptr, " t."))) {
  571.     if (*sep != '') {
  572.       cat = 0;
  573.       while (isdigit(*sep)) {
  574. cat *= 10;
  575. cat += *sep - '0';
  576. sep++;
  577.       }
  578.       if (cat == 0) {
  579. break;
  580.       }
  581.       new = malloc(sizeof(category_list_t));
  582.       if (new == NULL) {
  583. break;
  584.       }
  585.       new->category = cat;
  586.       new->next = NULL;
  587.       if (sptr->category_list == NULL) {
  588. cptr = sptr->category_list = new;
  589.       } else {
  590. cptr->next = new;
  591. cptr = new;
  592.       }
  593.     }
  594.   }
  595.   if (errret != 0) {
  596.     free_category_list(&sptr->category_list);
  597.   }
  598.   free(line);
  599.   return (errret);
  600. }
  602. /*
  603.  * sdp_decode_parse_a_frame()
  604.  * parses a=framerate:<float number>
  605.  */
  606. static int sdp_decode_parse_a_frame (int arg,
  607.      char *lptr,
  608.      session_desc_t *sptr,
  609.      media_desc_t *mptr)
  610. {
  611.   char *endptr;
  612.   
  613.   if (mptr == NULL) {
  614.     return (-1);
  615.   }
  617.   mptr->framerate = strtod(lptr, &endptr);
  618.   if (endptr == lptr || endptr == NULL) return (-1);
  619.   ADV_SPACE(endptr);
  620.   if (*endptr != '') {
  621.     sdp_debug(LOG_ERR, "Garbage at end of frame rate `%s'", endptr);
  622.     return (-1);
  623.   }
  624.   mptr->framerate_present = TRUE;
  625.   return (0);
  626. }
  628. static int convert_npt (char *from, char *to, double *ret)
  629. {
  630.   int decimal = FALSE;
  631.   double accum;
  632.   double mult;
  634.   *ret = 0.0;
  635.   mult = 0.0;
  636.   accum = 0.0;
  637.   
  638.   while ((to == NULL && *from != '') || from < to) {
  639.     if (isdigit(*from)) {
  640.       if (decimal == FALSE) {
  641. accum *= 10.0;
  642. accum += *from - '0';
  643.       } else {
  644. accum += ((*from - '0') * mult);
  645. mult /= 10.0;
  646.       }
  647.     } else if (*from == ':') {
  648.       accum *= 60.0;
  649.       *ret += accum;
  650.       accum = 0;
  651.     } else if (*from == '.') {
  652.       decimal = TRUE;
  653.       mult = .1;
  654.     } else {
  655.       sdp_debug(LOG_ERR, "Illegal character in NPT string %c", *from);
  656.       return (FALSE);
  657.     }
  658.     from++;
  659.   }
  660.   *ret += accum;
  661.   return (TRUE);
  662. }
  664. static int convert_smpte (char *from, char *to, uint16_t fps, double *ret)
  665. {
  666.   int decimal = FALSE;
  667.   double accum;
  668.   double mult;
  669.   unsigned int colon;
  671.   *ret = 0.0;
  672.   mult = 0.0;
  673.   accum = 0.0;
  674.   colon = 0;
  676.   if (fps == 0) fps = 30;
  677.   
  678.   while ((to == NULL && *from != '') || from < to) {
  679.     if (isdigit(*from)) {
  680.       if (decimal == FALSE) {
  681. accum *= 10.0;
  682. accum += (*from - '0');
  683.       } else {
  684. accum += ((*from - '0') * mult);
  685. mult /= 10.0;
  686.       }
  687.     } else if (*from == ':') {
  688.       *ret += accum;
  689.       if (colon > 1)
  690.         *ret *= fps;
  691.       else 
  692. *ret *= 60.0;
  693.       accum = 0.0;
  694.       colon++;
  695.     } else if (*from == '.') {
  696.       decimal = TRUE;
  697.       mult = .1;
  698.     } else {
  699.       sdp_debug(LOG_ERR, "Illegal character in SMPTE decode %c", *from);
  700.       return (FALSE);
  701.     }
  702.     from++;
  703.   }
  704.   *ret += accum;
  705.   if (colon <= 2) *ret *= fps;
  706.   return (TRUE);
  707. }
  709. static int sdp_decode_parse_a_range (int arg,
  710.      char *lptr,
  711.      session_desc_t *sptr,
  712.      media_desc_t *mptr)
  713. {
  714.   char *dash;
  715.   char *second;
  716.   range_desc_t *rptr;
  718.   if (mptr == NULL) rptr = &sptr->session_range;
  719.   else rptr = &mptr->media_range;
  721.   if (rptr->have_range) return (-1);
  722.   if (strncasecmp(lptr, "npt", strlen("npt")) == 0) {
  723.     lptr += strlen("npt");
  724.     rptr->range_is_npt = TRUE;
  725.   } else if (strncasecmp(lptr, "smpte", strlen("smpte")) == 0) {
  726.     lptr += strlen("smpte");
  727.     rptr->range_is_npt = FALSE;
  728.     if (*lptr == '-') {
  729.       lptr++;
  730.       if (strncasecmp(lptr, "30-drop", strlen("30-drop")) == 0) {
  731. rptr->range_smpte_fps = 0;
  732. lptr += strlen("30-drop");
  733.       } else {
  734. while (isdigit(*lptr)) {
  735.   rptr->range_smpte_fps *= 10;
  736.   rptr->range_smpte_fps += *lptr - '0';
  737.   lptr++;
  738. }
  739.       }
  740.     } else {
  741.       rptr->range_smpte_fps = 0;
  742.     }
  743.   } else {
  744.     sdp_debug(LOG_ERR, "range decode - unknown keyword %s", lptr);
  745.     return (-1);
  746.   }
  747.   ADV_SPACE(lptr);
  748.   if (*lptr != '=') {
  749.     sdp_debug(LOG_ERR, "range decode - no =");
  750.     return (-1);
  751.   }
  752.   lptr++;
  753.   ADV_SPACE(lptr);
  754.   dash = strchr(lptr, '-');
  755.   if (dash == NULL) return (-1);
  756.   if (rptr->range_is_npt) {
  757.     if (convert_npt(lptr, dash, &rptr->range_start) == FALSE) {
  758.       sdp_debug(LOG_ERR, "Couldn't decode range from npt %s", lptr);
  759.       return (-1);
  760.     }
  761.   } else {
  762.     if (convert_smpte(lptr,
  763.       dash,
  764.       rptr->range_smpte_fps,
  765.       &rptr->range_start) == FALSE) {
  766.       sdp_debug(LOG_ERR, "Couldn't decode range from smpte %s", lptr);
  767.       return (-1);
  768.     }
  769.   }
  770.       
  771.   second = dash + 1;
  772.   ADV_SPACE(second);
  773.   if (*second != '') {
  774.     if (rptr->range_is_npt) {
  775.       if (convert_npt(second, NULL, &rptr->range_end) == FALSE) {
  776. sdp_debug(LOG_ERR, "Couldn't decode range to npt %s", lptr);
  777. return (-1);
  778.       }
  779.     } else {
  780.       if (convert_smpte(second,
  781. NULL,
  782. rptr->range_smpte_fps,
  783. &rptr->range_end) == FALSE) {
  784. sdp_debug(LOG_ERR, "Couldn't decode range to smpte %s", lptr);
  785. return (-1);
  786.       }
  787.     }
  788.   } else {
  789.     rptr->range_end_infinite = TRUE;
  790.   }
  791.   rptr->have_range = TRUE;
  792.   return (0);
  793. }
  795. /*
  796.  * sdp_decode_parse_a_int()
  797.  * parses a=<name>:<uint>
  798.  */
  799. static int sdp_decode_parse_a_int (int arg,
  800.    char *orig_line,
  801.    session_desc_t *sptr,
  802.    media_desc_t *mptr)
  803. {
  804.   uint32_t num;
  806.   num = 0;
  807.   if (!isdigit(*orig_line)) {
  808.     return (-1);
  809.   }
  810.   while (isdigit(*orig_line)) {
  811.     num *= 10;
  812.     num += *orig_line - '0';
  813.     orig_line++;
  814.   }
  815.   ADV_SPACE(orig_line);
  816.   if (*orig_line != '') {
  817.     sdp_debug(LOG_ERR, "Garbage at end of integer %s", orig_line);
  818.     return(-1);
  819.   }
  821.   switch (arg) {
  822.   case 0:
  823.     if (mptr == NULL) return (-1);
  824.     mptr->ptime = num;
  825.     mptr->ptime_present = TRUE;
  826.     break;
  827.   case 1:
  828.     if (mptr == NULL) return (-1);
  829.     mptr->quality = num;
  830.     mptr->quality_present = TRUE;
  831.     break;
  832.   }
  833.   return (0);
  834. }
  836. /*
  837.  * check_value_list_or_user()
  838.  * This will compare string in lptr with items in list.  If strncasecmp()
  839.  * matches, and the next value after the match in lptr is a space or ,
  840.  * we return the index in list + 1.
  841.  * If no entrys are on the list, we'll strdup the value, and store in
  842.  * *uservalue
  843.  */
  844. static int check_value_list_or_user (char *lptr,
  845.      const char **list,
  846.      char **user_value)
  847. {
  848.   uint32_t len;
  849.   int cnt;
  851.   cnt = 1;
  852.   while (*list != NULL) {
  853.     len = strlen(*list);
  854.     if (strncasecmp(lptr, *list, len) == 0) {
  855.       return (cnt);
  856.     }
  857.     cnt++;
  858.     list++;
  859.   }
  860.   *user_value = strdup(lptr);
  861.   return(cnt);
  862. }
  864. const char *type_values[] = {
  865.   "broadcast", // CONFERENCE_TYPE_BROADCAST
  866.   "meeting",   // CONFERENCE_TYPE_MEETING
  867.   "moderated", // CONFERENCE_TYPE_MODERATED
  868.   "test",      // CONFERENCE_TYPE_TEST
  869.   "H332",      // CONFERENCE_TYPE_H332
  870.   NULL         // CONFERENCE_TYPE_USER
  871. };
  873. static const char *orient_values[] = {
  874.   "portrait", // ORIENT_TYPE_PORTRAIT
  875.   "landscape",// ORIENT_TYPE_LANDSCAPE
  876.   "seascape", // ORIENT_TYPE_SEASCAPE
  877.   NULL        // ORIENT_TYPE_USER
  878. };
  880. /*
  881.  * sdp_decode_parse_a_str()
  882.  * parses a=<identifier>:<name>
  883.  * Will usually save the value of <name> in a field in the media_desc_t or
  884.  * session_desc_t.
  885.  */
  886. static int sdp_decode_parse_a_str (int arg,
  887.    char *lptr,
  888.    session_desc_t *sptr,
  889.    media_desc_t *mptr)
  890. {
  891.   switch (arg) {
  892.   case 0: // keywds
  893.     if (sptr->keywds != NULL) {
  894.       sdp_debug(LOG_ERR, "2nd keywds statement");
  895.       return (-1);
  896.     }
  897.     sptr->keywds = strdup(lptr);
  898.     break;
  899.   case 1: // tool
  900.     if (sptr->tool != NULL) {
  901.       sdp_debug(LOG_ERR, "2nd tool statement");
  902.       return (-1);
  903.     }
  904.     sptr->tool = strdup(lptr);
  905.     break;
  906.   case 2: // charset
  907.     if (sptr->charset != NULL) {
  908.       sdp_debug(LOG_ERR, "2nd charset statement");
  909.       return (-1);
  910.     }
  911.     sptr->charset = strdup(lptr);
  912.     break;
  913.   case 3: // sdplang
  914.     if (mptr != NULL) {
  915.       if (mptr->sdplang != NULL) {
  916. sdp_debug(LOG_ERR, "2nd sdplang statement in media");
  917. return (-1);
  918.       }
  919.       mptr->sdplang = strdup(lptr);
  920.     } else {
  921.       if (sptr->sdplang != NULL) {
  922. sdp_debug(LOG_ERR, "2nd sdplang statement in session");
  923. return (-1);
  924.       }
  925.       sptr->sdplang = strdup(lptr);
  926.     }
  927.     break;
  928.   case 4: // lang
  929.     if (mptr != NULL) {
  930.       if (mptr->lang != NULL) {
  931. sdp_debug(LOG_ERR, "2nd lang statement in media");
  932. return (-1);
  933.       }
  934.       mptr->lang = strdup(lptr);
  935.     } else {
  936.       if (sptr->lang != NULL) {
  937. sdp_debug(LOG_ERR, "2nd lang statement in media");
  938. return (-1);
  939.       }
  940.       sptr->lang = strdup(lptr);
  941.     }
  942.     break;
  943.   case 5: // type
  944.     if (sptr->conf_type != 0) {
  945.       sdp_debug(LOG_ERR, "2nd conftype statement");
  946.       return (-1);
  947.     }
  948.     sptr->conf_type = check_value_list_or_user(lptr,
  949.        type_values,
  950.        &sptr->conf_type_user);
  951.     break;
  952.   case 6: // orient
  953.     if (mptr == NULL || mptr->orient_type != 0) {
  954.       sdp_debug(LOG_ERR, "2nd orient type statement");
  955.       return (-1);
  956.     }
  957.     mptr->orient_type = check_value_list_or_user(lptr,
  958.  orient_values,
  959.  &mptr->orient_user_type);
  960.     break;
  961.   case 7: // control
  962.     if (mptr == NULL) {
  963.       if (sptr->control_string != NULL) {
  964. sdp_debug(LOG_ERR, "2nd control statement in media");
  965. return (-1);
  966.       }
  967.       sptr->control_string = strdup(lptr);
  968.     } else {
  969.       if (mptr->control_string != NULL) {
  970. sdp_debug(LOG_ERR, "2nd control statement in session");
  971. return (-1);
  972.       }
  973.       mptr->control_string = strdup(lptr);
  974.     }
  975.     break;
  976.   case 8:
  977.     if (sptr->etag != NULL) {
  978.       sdp_debug(LOG_ERR, "2nd etag statement");
  979.       return (-1);
  980.     }
  981.     sptr->etag = strdup(lptr);
  982.     break;
  983.   }
  984.   return (0);
  985. }
  988. /*
  989.  * This structure provides the information needed by the parsing
  990.  * engine in sdp_decode_parse_a.  This function processes lines of
  991.  * the format a=<identifier>[:<options>].
  992.  * name - <identifier>
  993.  * len - sizeof(identifier) (saves on CPU time)
  994.  * have_colon - if a colon is necessary
  995.  * remove_spaces_after_colon - if colon is necessary, and we want
  996.  *   to remove spaces before <option>.  Do not use this if other character
  997.  *   sets may come into play.
  998.  * parse_routine - routine to call if keyword matched.  Return 0 if successful-
  999.  *   -1 will save the whole "a=..." string.
  1000.  * arg - value to pass to parse_routine
  1001.  */
  1002. static struct {
  1003.   char *name;
  1004.   uint32_t len;
  1005.   int have_colon;
  1006.   int remove_spaces_after_colon;
  1007.   int (*parse_routine)(int arg, char *lptr,
  1008.        session_desc_t *sptr, media_desc_t *mptr);
  1009.   int arg;
  1010. } a_types[] =
  1011. {
  1012.   { "rtpmap", sizeof("rtpmap"), TRUE, TRUE, sdp_decode_parse_a_rtpmap, 0 },
  1013.   { "cat", sizeof("cat"), TRUE, TRUE, sdp_decode_parse_a_cat, 0 },
  1014.   { "fmtp", sizeof("fmtp"), TRUE, TRUE, sdp_decode_parse_a_fmtp, 0 },
  1015.   { "keywds", sizeof("keywds"), TRUE, FALSE, sdp_decode_parse_a_str, 0},
  1016.   { "tool", sizeof("tool"), TRUE, TRUE, sdp_decode_parse_a_str, 1},
  1017.   { "charset", sizeof("charset"), TRUE, TRUE, sdp_decode_parse_a_str, 2},
  1018.   { "sdplang", sizeof("sdplang"), TRUE, TRUE, sdp_decode_parse_a_str, 3},
  1019.   { "lang", sizeof("lang"), TRUE, TRUE, sdp_decode_parse_a_str, 4},
  1020.   { "type", sizeof("type"), TRUE, TRUE, sdp_decode_parse_a_str, 5},
  1021.   { "orient", sizeof("orient"), TRUE, TRUE, sdp_decode_parse_a_str, 6},
  1022.   { "control", sizeof("control"), TRUE, TRUE, sdp_decode_parse_a_str, 7},
  1023.   { "etag", sizeof("etag"), TRUE, TRUE, sdp_decode_parse_a_str, 8},
  1024.   { "recvonly", sizeof("recvonly"), FALSE, FALSE, sdp_decode_parse_a_bool, 0},
  1025.   { "sendrecv", sizeof("sendrecv"), FALSE, FALSE, sdp_decode_parse_a_bool, 1},
  1026.   { "sendonly", sizeof("sendonly"), FALSE, FALSE, sdp_decode_parse_a_bool, 2},
  1027.   { "ptime", sizeof("ptime"), TRUE, TRUE, sdp_decode_parse_a_int, 0 },
  1028.   { "quality", sizeof("quality"), TRUE, TRUE, sdp_decode_parse_a_int, 1},
  1029.   { "framerate", sizeof("framerate"), TRUE, TRUE, sdp_decode_parse_a_frame, 0},
  1030.   { "range", sizeof("range"), TRUE, TRUE, sdp_decode_parse_a_range, 0 },
  1031.   { NULL, 0, FALSE, FALSE, NULL },
  1032. };
  1034. /*
  1035.  * sdp_decode_parse_a()
  1036.  * decodes a= lines, or stores the complete string in media or session
  1037.  * unparsed_a_lines list.
  1038.  */
  1039. static int sdp_decode_parse_a (char *lptr,
  1040.        char *line,
  1041.        session_desc_t *sptr,
  1042.        media_desc_t *mptr)
  1043. {
  1044.   int ix;
  1045.   int errret;
  1046.   int parsed;
  1047.   char *after;
  1048.   
  1049.   ix = 0;
  1050.   errret = 0;
  1051.   parsed = FALSE;
  1052.   /*
  1053.    * go through above array, looking for a complete match
  1054.    */
  1055.   while (a_types[ix].name != NULL) {
  1056.     if (strncasecmp(lptr,
  1057.     a_types[ix].name,
  1058.     a_types[ix].len - 1) == 0) {
  1059.       after = lptr + a_types[ix].len - 1;
  1060.       if (!(isspace(*after) ||
  1061.     *after == ':' ||
  1062.     *after == '')) {
  1063. // partial match - not good enough
  1064. continue;
  1065.       }
  1066.    
  1067.       parsed = TRUE;
  1069.       /*
  1070.        * Have a match.  If specified, look for colon, and remove space
  1071.        * after colon
  1072.        */
  1073.       if (a_types[ix].have_colon) {
  1074. ADV_SPACE(after);
  1075. if (*after != ':') {
  1076.   errret = ESDP_ATTRIBUTES_NO_COLON;
  1077.   break;
  1078. }
  1079. after++;
  1080. if (a_types[ix].remove_spaces_after_colon) {
  1081.   ADV_SPACE(after);
  1082. }
  1083.       }
  1084.       /*
  1085.        * Call the correct parsing routine
  1086.        */
  1087.       errret = (a_types[ix].parse_routine)(a_types[ix].arg, after, sptr, mptr);
  1088.       break;
  1089.     }
  1090.     ix++;
  1091.   }
  1092.   /*
  1093.    * Worse comes to worst, store the whole line
  1094.    */
  1095.   if (parsed == FALSE || errret != 0) {
  1096.     if (sdp_add_string_to_list(mptr == NULL ?
  1097.    &sptr->unparsed_a_lines :
  1098.    &mptr->unparsed_a_lines,
  1099.    line) == FALSE) {
  1100.       return (ENOMEM);
  1101.     }
  1102.   }
  1103.   return (0);
  1104. }
  1106. /*
  1107.  * sdp_decode_parse_bandwidth()
  1108.  * parses b=<modifier>:<value>
  1109.  * Inputs: lptr - pointer to line, bptr - pointer to store in
  1110.  * Outputs: TRUE - valid, FALSE, invalid
  1111.  */
  1112. static int sdp_decode_parse_bandwidth (char *lptr,
  1113.        bandwidth_t **bptr)
  1114. {
  1115.   char *cptr, *endptr;
  1116.   bandwidth_t *new, *p;
  1117.   bandwidth_modifier_t modifier;
  1118.   uint32_t temp;
  1119.   cptr = strchr(lptr, ':');
  1120.   if (cptr == NULL) {
  1121.     sdp_debug(LOG_ERR, "No colon in bandwidth");
  1122.     return (ESDP_BANDWIDTH);
  1123.   }
  1124.   *cptr++ = '';
  1125.   
  1126.   if (strncasecmp(lptr, "as", strlen("as")) == 0) {
  1127.     modifier = BANDWIDTH_MODIFIER_AS;
  1128.   } else if (strncasecmp(lptr, "ct", strlen("ct")) == 0) {
  1129.     modifier = BANDWIDTH_MODIFIER_CT;
  1130.   } else {
  1131.     modifier = BANDWIDTH_MODIFIER_USER;
  1132.     endptr = cptr - 2;
  1133.     while (isspace(*endptr) && endptr >lptr) *endptr-- = '';
  1134.   }
  1136.   if (*cptr == '') {
  1137.     sdp_debug(LOG_ERR, "No bandwidth in bandwidth");
  1138.     return (ESDP_BANDWIDTH);
  1139.   }
  1140.   temp = strtoul(cptr, &endptr, 10);
  1141.   if (*endptr != '') {
  1142.     sdp_debug(LOG_ERR, "Error in decoding bandwidth value %s", cptr);
  1143.     return (ESDP_BANDWIDTH);
  1144.   }
  1145.   
  1146.   new = malloc(sizeof(bandwidth_t));
  1147.   if (new == NULL) {
  1148.     return (ENOMEM);
  1149.   }
  1150.   new->modifier = modifier;
  1151.   if (modifier == BANDWIDTH_MODIFIER_USER) {
  1152.     new->user_band = strdup(lptr);
  1153.     if (new->user_band == NULL) {
  1154.       free(new);
  1155.       return (ENOMEM);
  1156.     }
  1157.   } else {
  1158. new->user_band = NULL;
  1159.   }
  1160.   new->bandwidth = temp;
  1161.   new->next = NULL;
  1162.   if (*bptr == NULL) {
  1163.     *bptr = new;
  1164.   } else {
  1165.     p = *bptr;
  1166.     while (p->next != NULL) p = p->next;
  1167.     p->next = new;
  1168.   }
  1169.   return (0);
  1170. }
  1172. /*
  1173.  * sdp_decode_parse_connect()
  1174.  * parse c=<network type> <address type> <connect address>
  1175.  * Inputs: lptr, connect pointer
  1176.  * Outputs - error code or 0 if parsed correctly
  1177.  */
  1178. static int sdp_decode_parse_connect (char *lptr, connect_desc_t *cptr)
  1179. {
  1180.   char *sep, *beg;
  1182.   cptr->ttl = 0;
  1183.   cptr->num_addr = 0;
  1185.   // <network type> should be IN
  1186.   sep = strsep(&lptr, SPACES);
  1187.   if (sep == NULL ||
  1188.       lptr == NULL ||
  1189.       strcasecmp(sep, "IN") != 0) {
  1190.     sdp_debug(LOG_ERR, "IN statement missing from c");
  1191.     return (ESDP_CONNECT);
  1192.   }
  1194.   // <address type> - should be IPV4
  1195.   ADV_SPACE(lptr);
  1196.   sep = strsep(&lptr, SPACES);
  1197.   if (sep == NULL || lptr == NULL) {
  1198.     sdp_debug(LOG_ERR, "No connection type in c=");
  1199.     return (ESDP_CONNECT);
  1200.   }
  1201.   cptr->conn_type = strdup(sep);
  1203.   // Address - first look if we have a / - that indicates multicast, and a
  1204.   // ttl.
  1205.   ADV_SPACE(lptr);
  1206.   sep = strchr(lptr, '/');
  1207.   if (sep == NULL) {
  1208.     // unicast address
  1209.     cptr->conn_addr = strdup(lptr);
  1210.     cptr->used = TRUE;
  1211.     return (0);
  1212.   }
  1214.   // Okay - multicast address.  Take address up to / (get rid of trailing
  1215.   // spaces)
  1216.   beg = lptr;
  1217.   lptr = sep + 1;
  1218.   sep--;
  1219.   while (isspace(*sep) && sep > beg) sep--;
  1220.   sep++;
  1221.   *sep = '';
  1222.   cptr->conn_addr = strdup(beg);
  1224.   // Now grab the ttl
  1225.   ADV_SPACE(lptr);
  1226.   sep = strsep(&lptr, " t/");
  1227.   if (!isdigit(*sep)) {
  1228.     free_connect_desc(cptr);
  1229.     sdp_debug(LOG_ERR, "No multicast TTL in c=");
  1230.     return (ESDP_CONNECT);
  1231.   }
  1232.   sscanf(sep, "%u", &cptr->ttl);
  1233.   // And see if we have a number of ports
  1234.   if (lptr != NULL) {
  1235.     // we have a number of ports, as well
  1236.     ADV_SPACE(lptr);
  1237.     if (!isdigit(*lptr)) {
  1238.       sdp_debug(LOG_ERR, "c=: garbage after multicast ttl %s", lptr);
  1239.       free_connect_desc(cptr);
  1240.       return (ESDP_CONNECT);
  1241.     }
  1242.     sscanf(lptr, "%u", &cptr->num_addr);
  1243.   }
  1244.   cptr->used = TRUE;
  1245.   return (0);
  1246. }
  1249. /*
  1250.  * sdp_decode_parse_key()
  1251.  */
  1252. static int sdp_decode_parse_key (char *lptr, key_desc_t *kptr)
  1253. {
  1254.   if (strncmp(lptr, "prompt", strlen("prompt")) == 0) {
  1255.     // handle prompt command
  1256.     kptr->key_type = KEY_TYPE_PROMPT;
  1257.     return (0);
  1258.   }
  1259.   if (strncasecmp(lptr, "clear", strlen("clear")) == 0) {
  1260.     kptr->key_type = KEY_TYPE_CLEAR;
  1261.     lptr += strlen("clear");
  1262.   } else if (strncasecmp(lptr, "base64", strlen("base64")) == 0) {
  1263.     kptr->key_type = KEY_TYPE_BASE64;
  1264.     lptr += strlen("base64");
  1265.   } else if (strncasecmp(lptr, "uri", strlen("uri")) == 0) {
  1266.     kptr->key_type = KEY_TYPE_URI;
  1267.     lptr += strlen("uri");
  1268.   } else {
  1269.     sdp_debug(LOG_ERR, "key statement keyword error %s", lptr);
  1270.     return (ESDP_KEY);
  1271.   }
  1272.   ADV_SPACE(lptr);
  1273.   if (*lptr != ':') {
  1274.     return (ESDP_KEY);
  1275.   }
  1276.   lptr++;
  1277.   // Because most of the types can have spaces, we take everything after
  1278.   // the colon here.  To eliminate the whitespace, use ADV_SPACE(lptr);
  1279.   kptr->key = strdup(lptr);
  1280.   return (0);
  1281. }
  1284. /*
  1285.  * sdp_decode_parse_media()
  1286.  * decodes m= lines.
  1287.  * m=<media> <port>[/<numport>] <proto> <fmt list>
  1288.  * Inputs:
  1289.  *   lptr - pointer to line
  1290.  *   sptr - pointer to session description to modify
  1291.  * Outputs:
  1292.  *   pointer to new media description
  1293.  */
  1294. static media_desc_t *sdp_decode_parse_media (char *lptr,
  1295.      session_desc_t *sptr,
  1296.      int *err)
  1297. {
  1298.   char *mdesc, *proto, *sep;
  1299.   media_desc_t *new, *mp;
  1300.   uint32_t read, port_no;
  1301.   string_list_t *q;
  1303.   *err = 0;
  1304.   // m=<media> <port> <transport> <fmt list>
  1305.   mdesc = strsep(&lptr, SPACES);
  1306.   if (mdesc == NULL || lptr == NULL) {
  1307.     sdp_debug(LOG_CRIT, "No media type");
  1308.     *err = ESDP_MEDIA;
  1309.     return (NULL);
  1310.   }
  1312.   // <port>
  1313.   ADV_SPACE(lptr);
  1314.   read = 0;
  1315.   if (!isdigit(*lptr)) {
  1316.     sdp_debug(LOG_ERR, "Illegal port number in media %s", lptr);
  1317.     *err = ESDP_MEDIA;
  1318.     return (NULL);
  1319.   }
  1320.   while (isdigit(*lptr)) {
  1321.     read *= 10;
  1322.     read += *lptr - '0';
  1323.     lptr++;
  1324.   }
  1325.   ADV_SPACE(lptr);
  1327.   // number of ports (optional)
  1328.   if (*lptr == '/') {
  1329.     lptr++;
  1330.     ADV_SPACE(lptr);
  1331.     if (!isdigit(*lptr)) {
  1332.       sdp_debug(LOG_ERR, "Illegal port number in media %s", lptr);
  1333.       *err = ESDP_MEDIA;
  1334.       return (NULL);
  1335.     }
  1336.     sep = strsep(&lptr, SPACES);
  1337.     if (lptr == NULL) {
  1338.       sdp_debug(LOG_ERR, "Missing keywords in media");
  1339.       *err = ESDP_MEDIA;
  1340.       return (NULL);
  1341.     }
  1342.     sscanf(sep, "%u", &port_no);
  1343.     ADV_SPACE(lptr);
  1344.   } else {
  1345.     port_no = 0;
  1346.   }
  1348.   // <transport> (protocol)
  1349.   proto = strsep(&lptr, SPACES);
  1350.   if (proto == NULL || lptr == NULL) {
  1351.     sdp_debug(LOG_ERR, "No transport in media");
  1352.     *err = ESDP_MEDIA;
  1353.     return (NULL);
  1354.   }
  1355.   ADV_SPACE(lptr);
  1356.   if (!isalnum(*lptr)) {
  1357.     *err = ESDP_MEDIA;
  1358.     return (NULL);
  1359.   }  
  1361.   // malloc memory and set.
  1362.   new = malloc(sizeof(media_desc_t));
  1363.   if (new == NULL) {
  1364.     *err = ENOMEM;
  1365.     return (NULL);
  1366.   }
  1367.   memset(new, 0, sizeof(media_desc_t));
  1368.   new->media = strdup(mdesc);
  1369.   new->port = (uint16_t)read;
  1370.   new->proto = strdup(proto);
  1371.   new->num_ports = (unsigned short)port_no;
  1373.   // parse format list - these are not necessarilly lists of numbers
  1374.   // so we store as strings.
  1375.   q = NULL;
  1376.   do {
  1377.     sep = strsep(&lptr, SPACES);
  1378.     if (sep != NULL) {
  1379.       if (sdp_add_format_to_list(new, sep) == NULL) {
  1380. free_media_desc(new);
  1381. *err = ENOMEM;
  1382. return (NULL);
  1383.       }
  1384.       if (lptr != NULL) {
  1385. ADV_SPACE(lptr);
  1386.       }
  1387.     }
  1388.   } while (sep != NULL);
  1390.   new->parent = sptr;
  1391.   // Add to list of media
  1392.   if (sptr->media == NULL) {
  1393.     sptr->media = new;
  1394.   } else {
  1395.     mp = sptr->media;
  1396.     while (mp->next != NULL) mp = mp->next;
  1397.     mp->next = new;
  1398.   }
  1399.   
  1400.   return (new);
  1401. }
  1403. /*
  1404.  * sdp_decode_parse_origin()
  1405.  * parses o= line
  1406.  * o=<username> <session id> <version> <network type> <addr type> <addr>
  1407.  *
  1408.  * Inputs:
  1409.  *   lptr - pointer to line to parse
  1410.  *   sptr - session desc
  1411.  * Output - TRUE, valid, FALSE, invalid
  1412.  */
  1413. static int sdp_decode_parse_origin (char *lptr, session_desc_t *sptr)
  1414. {
  1415.   char *username, *sep;
  1417.   // Username - leave null if "-"
  1418.   username = strsep(&lptr, SPACES);
  1419.   if (username == NULL || lptr == NULL) {
  1420.     sdp_debug(LOG_ERR, "o=: no username");
  1421.     return (ESDP_ORIGIN);
  1422.   }
  1423.   ADV_SPACE(lptr);
  1424.   if (strcmp(username, "-") != 0) {
  1425.     sptr->orig_username = strdup(username);
  1426.   }
  1427.     
  1428.   if (strtou64(&lptr, &sptr->session_id) == FALSE) {
  1429.     sdp_debug(LOG_ERR, "Non-numeric session id");
  1430.     return (ESDP_ORIGIN);
  1431.   }
  1433.   if (strtou64(&lptr, &sptr->session_version) == FALSE) {
  1434.     sdp_debug(LOG_ERR, "Non-numeric session version");
  1435.     return (ESDP_ORIGIN);
  1436.   }
  1437.   
  1438.   ADV_SPACE(lptr);
  1439.   sep = strsep(&lptr, SPACES);
  1440.   if ((sep == NULL) ||
  1441.       (lptr == NULL) ||
  1442.       (strcasecmp(sep, "IN") != 0)) {
  1443.     sdp_debug(LOG_ERR, "o=: no IN statement");
  1444.     return (ESDP_ORIGIN);
  1445.   }
  1447.   ADV_SPACE(lptr);
  1448.   sep = strsep(&lptr, SPACES);
  1449.   if (sep == NULL || lptr == NULL) {
  1450.     sdp_debug(LOG_ERR, "o=: No creation address type");
  1451.     return (ESDP_ORIGIN);
  1452.   }
  1453.   sptr->create_addr_type = strdup(sep);
  1455.   ADV_SPACE(lptr);
  1456.   sep = strsep(&lptr, SPACES);
  1457.   if (sep == NULL) {
  1458.     sdp_debug(LOG_ERR, "o=: No creation address");
  1459.     return (ESDP_ORIGIN);
  1460.   }
  1461.   sptr->create_addr = strdup(sep);
  1462.   
  1463.   return (0);
  1464. }
  1466. /*
  1467.  * sdp_decode_parse_time()
  1468.  * decode t= statements
  1469.  *
  1470.  * Inputs:
  1471.  *   sptr - pointer to session_desc_t to write into.
  1472.  *   lptr - pointer to line.  Should point at first number (spaces removed)
  1473.  *
  1474.  * Outputs:
  1475.  *   pointer to session_time_desc_t to use as current one.
  1476.  *   NULL if string invalid
  1477.  */
  1478. static session_time_desc_t *sdp_decode_parse_time (char *lptr,
  1479.    session_desc_t *sptr,
  1480.    int *err)
  1481. {
  1482.   session_time_desc_t *tptr;
  1483.   uint32_t start, end;
  1485.   *err = 0;
  1486.   if (!isdigit(*lptr)) {
  1487.     *err = ESDP_TIME;
  1488.     sdp_debug(LOG_ERR, "t= statement has illegal first character %c", *lptr);
  1489.     return (NULL);
  1490.   }
  1492.   start = end = 0;
  1493.   
  1494.   while (isdigit(*lptr)) {
  1495.     start *= 10;
  1496.     start += *lptr - '0';
  1497.     lptr++;
  1498.   }
  1500.   ADV_SPACE(lptr);
  1502.   if (!isdigit(*lptr)) {
  1503.     sdp_debug(LOG_ERR,
  1504.       "t= statement has illegal character after 1st number %c",
  1505.       *lptr);
  1506.     *err = ESDP_TIME;
  1507.     return (NULL);
  1508.   }
  1509.   
  1510.   while (isdigit(*lptr)) {
  1511.     end *= 10;
  1512.     end += *lptr - '0';
  1513.     lptr++;
  1514.   }
  1515.   
  1516.   tptr = malloc(sizeof(session_time_desc_t));
  1517.   if (tptr == NULL) {
  1518.     *err = ENOMEM;
  1519.     return (NULL);
  1520.   }
  1522.   tptr->next = NULL;
  1523.   tptr->repeat = NULL;
  1525.   // Convert from NTP time to Unix time (unless time is 0)
  1526.   tptr->start_time = (start == 0) ? 0 : (start - NTP_TO_UNIX_TIME);
  1527.   tptr->end_time = (end == 0) ? 0 : (end - NTP_TO_UNIX_TIME);
  1529.   // Add to end of linked list of time descriptions
  1530.   if (sptr->time_desc == NULL) {
  1531.     sptr->time_desc = tptr;
  1532.   } else {
  1533.     session_time_desc_t *q;
  1534.     q = sptr->time_desc;
  1535.     while (q->next != NULL) q = q->next;
  1536.     q->next = tptr;
  1537.   }
  1538.   
  1539.   return (tptr);
  1540.   
  1541. }
  1543. /*
  1544.  * sdp_decode_parse_time_adj()
  1545.  * decode z= fields.
  1546.  * Inputs: lptr - pointer to line to decode
  1547.  *   session - pointer to session_descriptor to add
  1548.  * Returns:
  1549.  *   TRUE - valid line
  1550.  *   FALSE - invalid line
  1551.  */
  1552. static int sdp_decode_parse_time_adj (char *lptr,
  1553.       session_desc_t *session)
  1554. {
  1555.   char *sep;
  1556.   int valid;
  1557.   time_adj_desc_t *start_aptr, *aptr;
  1558.   time_t adj_time;
  1559.   int32_t offset;
  1560.   int possign;
  1561.   int err;
  1562.   
  1563.   if (!isdigit(*lptr)) {
  1564.     sdp_debug(LOG_ERR, "Illegal character for z= field %s", lptr);
  1565.     return (ESDP_TIME_ADJ);
  1566.   }
  1568.   start_aptr = NULL;
  1569.   valid = TRUE;
  1570.   /*
  1571.    * parse pairs of <adjustment time> <offset>
  1572.    */
  1573.   err = ESDP_TIME_ADJ;
  1574.   
  1575.   while ((sep = strsep(&lptr, SPACES)) && valid == TRUE) {
  1576.     if (lptr == NULL) {
  1577.       valid = FALSE;
  1578.       continue;
  1579.     }
  1580.     // process <adjustment time> - adjust it from NTP to unix time
  1581.     sscanf(sep, "%ld", &adj_time);
  1583.     // Check for negative sign for offset.
  1584.     ADV_SPACE(lptr);
  1585.     if (*lptr == '-') {
  1586.       possign = FALSE;
  1587.       lptr++;
  1588.     } else possign = TRUE;
  1589.     ADV_SPACE(lptr);
  1590.     
  1591.     sep = strsep(&lptr, SPACES);
  1592.     if (adj_time == 0 || sep == NULL) {
  1593.       valid = FALSE;
  1594.       continue;
  1595.     }
  1596.     adj_time -= NTP_TO_UNIX_TIME;
  1598.     // Process offset - could be positive or negative.
  1599.     if (str_to_time_offset(sep, &offset) == FALSE) {
  1600.       valid = FALSE;
  1601.       continue;
  1602.     }
  1604.     if (possign == FALSE) offset = 0 - offset;
  1606.     /*
  1607.      * create a time structure - order the link list by value
  1608.      * of adj_times
  1609.      */
  1610.     aptr = malloc(sizeof(time_adj_desc_t));
  1611.     if (aptr == NULL) {
  1612.       valid = FALSE;
  1613.       err = ENOMEM;
  1614.       continue;
  1615.     }
  1616.     
  1617.     aptr->next = NULL;
  1618.     aptr->adj_time = adj_time;
  1619.     aptr->offset = offset;
  1620.     if (lptr != NULL) {
  1621.       ADV_SPACE(lptr);
  1622.     }
  1624.     start_aptr = time_adj_order_in_list(start_aptr, aptr);
  1625.     
  1626.   }
  1628.   if (valid == FALSE) {
  1629.     while (start_aptr != NULL) {
  1630.       aptr = start_aptr;
  1631.       start_aptr = aptr->next;
  1632.       free(aptr);
  1633.     }
  1634.     return (err);
  1635.   }
  1637.   if (start_aptr == NULL) return (err);
  1639.   while (start_aptr != NULL) {
  1640.     aptr = start_aptr->next;
  1641.     start_aptr = aptr->next;
  1642.     aptr->next = NULL;
  1643.     session->time_adj_desc = time_adj_order_in_list(session->time_adj_desc,
  1644.     aptr);
  1645.   }
  1647.   return (0);
  1648. }
  1651. /*
  1652.  * sdp_decode_parse_time_repeat
  1653.  * parse "r=" field in SDP description, store info off of current time
  1654.  * pointer
  1655.  *
  1656.  * Inputs : lptr - pointer to decode buffer
  1657.  *    current_time - current time pointer returned by sdp_decode_parse_time()
  1658.  *
  1659.  * Outputs - TRUE - decoded successfully - FALSE - error
  1660.  */
  1661. static int sdp_decode_parse_time_repeat (char *lptr,
  1662.  session_time_desc_t *current_time)
  1663. {
  1664.   time_repeat_desc_t *rptr;
  1665.   char *sep;
  1666.   uint32_t interval, duration;
  1667.   
  1668.   if (current_time == NULL) {
  1669.     sdp_debug(LOG_ERR, "r= before or without time");
  1670.     return (ESDP_REPEAT_NOTIME);
  1671.   }
  1673.   sep = strsep(&lptr, SPACES);
  1674.   if (sep == NULL || lptr == NULL) {
  1675.     sdp_debug(LOG_ERR, "Interval not found in repeat statment");
  1676.     return (ESDP_REPEAT);
  1677.   }
  1679.   if (str_to_time_offset(sep, &interval) == FALSE) {
  1680.     sdp_debug(LOG_ERR, "Illegal string conversion in repeat");
  1681.     return (ESDP_REPEAT);
  1682.   }
  1683.   
  1684.   ADV_SPACE(lptr);
  1685.   sep = strsep(&lptr, SPACES);
  1686.   if (sep == NULL || lptr == NULL) {
  1687.     sdp_debug(LOG_ERR, "No duration in repeat statement");
  1688.     return (ESDP_REPEAT);
  1689.   }
  1691.   if (str_to_time_offset(sep, &duration) == FALSE) {
  1692.     return (ESDP_REPEAT);
  1693.   }
  1694.   
  1695.   if (duration == 0 || interval == 0) {
  1696.     sdp_debug(LOG_ERR, "duration or interval are 0 in repeat");
  1697.     return (ESDP_REPEAT);
  1698.   }
  1700.   ADV_SPACE(lptr);
  1701.   
  1702.   rptr = malloc(sizeof(time_repeat_desc_t));
  1703.   if (rptr == NULL)
  1704.     return (ENOMEM);
  1706.   rptr->next = NULL;
  1707.   rptr->offset_cnt = 0;
  1708.   rptr->repeat_interval = interval;
  1709.   rptr->active_duration = duration;
  1711.   // Read offset fields - we set a maximum of 16 here.
  1712.   while ((sep = strsep(&lptr, SPACES)) &&
  1713.  rptr->offset_cnt < MAX_REPEAT_OFFSETS) {
  1714.     if (str_to_time_offset(sep, &rptr->offsets[rptr->offset_cnt]) == FALSE) {
  1715.       sdp_debug(LOG_ERR, "Illegal repeat offset - number %d", rptr->offset_cnt);
  1716.       free(rptr);
  1717.       return (ESDP_REPEAT);
  1718.     }
  1719.     rptr->offset_cnt++;
  1720.     if (lptr != NULL) {
  1721.       ADV_SPACE(lptr);
  1722.     }
  1723.   }
  1725.   if (rptr->offset_cnt == 0 || sep != NULL) {
  1726.     sdp_debug(LOG_ERR, "No listed offset in repeat");
  1727.     free(rptr);
  1728.     return (ESDP_REPEAT);
  1729.   }
  1730.   
  1731.   if (current_time->repeat == NULL) {
  1732.     current_time->repeat = rptr;
  1733.   } else {
  1734.     time_repeat_desc_t *q;
  1735.     q = current_time->repeat;
  1736.     while (q->next != NULL) q = q->next;
  1737.     q->next = rptr;
  1738.   }
  1739.   return (0);
  1740. }
  1742. /*****************************************************************************
  1743.  * Main library routines
  1744.  *****************************************************************************/
  1746. /*
  1747.  * sdp_decode()
  1748.  * main routine
  1749.  * Inputs:
  1750.  *   decode - pointer to sdp_decode_info_t set before calling.
  1751.  *   retlist - pointer to pointer of list head
  1752.  *   translated - pointer to return number translated
  1753.  * Outputs:
  1754.  *   error code or 0.  Negative error codes are local, positive are errorno.
  1755.  *   retlist - pointer to list of session_desc_t.
  1756.  *   translated - number translated.
  1757.  */
  1758. int sdp_decode (sdp_decode_info_t *decode,
  1759. session_desc_t **retlist,
  1760. int *translated)
  1761. {
  1762.   char *line, *lptr;
  1763.   char code;
  1764.   int errret;
  1765.   uint32_t linelen;
  1767.   session_desc_t *first_session,*sptr;
  1768.   media_desc_t *current_media;
  1769.   session_time_desc_t *current_time;
  1770.   if ((decode == NULL) || (decode->isSet != TRUE)) {
  1771.     return -EINVAL;
  1772.   }
  1774.   *retlist = first_session = NULL;
  1775.   sptr = NULL;
  1776.   current_media = NULL;
  1777.   current_time = NULL;
  1778.   *translated = 0;
  1779.   errret = 0;
  1780.   line = NULL;
  1781.   linelen = 0;
  1782.   while (errret == 0 && get_next_line(&line, decode, &linelen) != FALSE) {
  1783.     lptr = line;
  1784.     ADV_SPACE(lptr);
  1785.     /*
  1786.      * All spaces ?  Just go to next line.
  1787.      */
  1788.     if (*lptr == '')
  1789.       continue;
  1790.     sdp_debug(LOG_DEBUG, "'%s'",  lptr);
  1791.     /*
  1792.      * Let's be strict about 1 character code
  1793.      */
  1794.     code = *lptr++;
  1795.     ADV_SPACE(lptr);
  1796.     if (*lptr == '=') {
  1797.       lptr++;
  1798.       ADV_SPACE(lptr);
  1799.       if ((sptr == NULL) && (tolower(code) != 'v')) {
  1800. sdp_debug(LOG_ERR, "Version not 1st statement");
  1801. errret = ESDP_INVVER;
  1802. break;
  1803.       }
  1804.       switch (tolower(code)) {
  1805.       case 'v': {
  1806. int ver;
  1807. if ((sscanf(lptr, "%u", &ver) != 1) ||
  1808.     (ver != 0)) {
  1809.   errret = ESDP_INVVER;
  1810.   sdp_debug(LOG_ERR, "SDP Version not correct, %s", line);
  1811.   break;
  1812. }
  1813. /*
  1814.  * Next session...
  1815.  */
  1816. sptr = malloc(sizeof(session_desc_t));
  1817. if (sptr == NULL) {
  1818.   errret = ENOMEM;
  1819.   break;
  1820. }
  1821. memset(sptr, 0, sizeof(session_desc_t));
  1822. if (first_session == NULL) {
  1823.   *retlist = first_session = sptr;
  1824. } else {
  1825.   session_desc_t *p;
  1826.   p = first_session;
  1827.   while (p->next != NULL) p = p->next;
  1828.   p->next = sptr;
  1829. }
  1830. *translated = *translated + 1;
  1831. current_media = NULL;
  1832. current_time = NULL;
  1833. break;
  1834.       }
  1835.       case 'o':
  1836. errret = sdp_decode_parse_origin(lptr, sptr);
  1837. break;
  1838.       case 's':
  1839. sptr->session_name = strdup(lptr);
  1840. if (sptr->session_name == NULL) {
  1841.   errret = ENOMEM;
  1842. }
  1843. break;
  1844.       case 'i':
  1845. if (current_media != NULL) {
  1846.   current_media->media_desc = strdup(lptr);
  1847.   if (current_media->media_desc == NULL) {
  1848.     errret = ENOMEM;
  1849.   }
  1850. } else {
  1851.   sptr->session_desc = strdup(lptr);
  1852.   if (sptr->session_desc == NULL) {
  1853.     errret = ENOMEM;
  1854.   }
  1855. }
  1856. break;
  1857.       case 'u':
  1858. sptr->uri = strdup(lptr);
  1859. if (sptr->uri == NULL) {
  1860.   errret = ENOMEM;
  1861. }
  1862. break;
  1863.       case 'e':
  1864. if (sdp_add_string_to_list(&sptr->admin_email, lptr) == FALSE) {
  1865.   errret = ENOMEM;
  1866. }
  1867. break;
  1868.       case 'p':
  1869. if (sdp_add_string_to_list(&sptr->admin_phone, lptr) == FALSE) {
  1870.   errret = ENOMEM;
  1871. }
  1872. break;
  1873.       case 'c':
  1874. errret = sdp_decode_parse_connect(lptr,
  1875.   current_media ?
  1876.   &current_media->media_connect :
  1877.   &sptr->session_connect);
  1878. break;
  1879.       case 'b':
  1880. errret= sdp_decode_parse_bandwidth(lptr,
  1881.    current_media != NULL ?
  1882.    &current_media->media_bandwidth :
  1883.    &sptr->session_bandwidth);
  1884. break;
  1885.       case 't':
  1886. current_time = sdp_decode_parse_time(lptr, sptr, &errret);
  1887. if (current_time == NULL) {
  1888.   errret = ESDP_TIME;
  1889. }
  1890. break;
  1891.       case 'r':
  1892. if (current_time != NULL) {
  1893.   errret = sdp_decode_parse_time_repeat(lptr, current_time);
  1894. }
  1895. break;
  1896.       case 'z':
  1897. errret = sdp_decode_parse_time_adj(lptr, sptr);
  1898. break;
  1899.       case 'k':
  1900. errret = sdp_decode_parse_key(lptr,
  1901.       current_media == NULL ? &sptr->key :
  1902.       &current_media->key);
  1903. break;
  1904.       case 'a':
  1905. errret = sdp_decode_parse_a(lptr, line, sptr, current_media);
  1906. break;
  1907.       case 'm':
  1908. current_media = sdp_decode_parse_media(lptr, sptr, &errret);
  1909. break;
  1910.       default:
  1911. sdp_debug(LOG_ERR, "unknown code - %s", line);
  1912. errret = ESDP_UNKNOWN_LINE;
  1913.       }
  1914.     } else {
  1915.       // bigger than 1 character code
  1916.       sdp_debug(LOG_ERR, "More than 1 character code - %s", line);
  1917.       errret = ESDP_UNKNOWN_LINE;
  1918.     }
  1919.   }
  1922.   if (line != NULL) {
  1923.     free(line);
  1924.   }
  1926.   if (errret != 0) {
  1927.     if (sptr != NULL) {
  1928.       if (first_session == sptr) {
  1929. *retlist = NULL;
  1930.       } else {
  1931. session_desc_t *p;
  1932. p = first_session;
  1933. while (p->next != sptr) {
  1934.   p = p->next;
  1935. }
  1936. p->next = NULL;
  1937.       }
  1938.       sdp_free_session_desc(sptr);
  1939.     }
  1940.     sdp_debug(LOG_ALERT, "SDP decode failure %d", errret);
  1941.     return (errret);
  1942.   }
  1943.   return (0);
  1944. }
  1946. /*
  1947.  * set_sdp_decode_from_memory()
  1948.  * Allows sdp decode to be run from a memory block.
  1949.  *
  1950.  * Inputs: memptr - pointer to memory.  Won't be touched.
  1951.  * Outputs: pointer to sdp_decode_info_t to be used.
  1952.  */
  1953. sdp_decode_info_t *set_sdp_decode_from_memory (const char *memptr)
  1954. {
  1955.   sdp_decode_info_t *decode_ptr;
  1957.   decode_ptr = malloc(sizeof(sdp_decode_info_t));
  1958.   if (decode_ptr == NULL)
  1959.     return (NULL);
  1960.   
  1961.   memset(decode_ptr, 0, sizeof(sdp_decode_info_t));
  1963.   decode_ptr->isSet = TRUE;
  1964.   decode_ptr->isMem = TRUE;
  1965.   decode_ptr->memptr = memptr;
  1966.   decode_ptr->filename = NULL;
  1967.   decode_ptr->ifile = NULL;
  1968.   return (decode_ptr);
  1969. }
  1971. /*
  1972.  * set_sdp_decode_from_filename()
  1973.  * Allows sdp decode to be run on a file
  1974.  *
  1975.  * Inputs: filename - name of file to open
  1976.  * Outputs: pointer to sdp_decode_info_t to be used.
  1977.  */
  1978. sdp_decode_info_t *set_sdp_decode_from_filename (const char *filename)
  1979. {
  1980.   sdp_decode_info_t *decode_ptr;
  1982.   decode_ptr = malloc(sizeof(sdp_decode_info_t));
  1983.   if (decode_ptr == NULL)
  1984.     return (NULL);
  1985.   
  1986.   memset(decode_ptr, 0, sizeof(sdp_decode_info_t));
  1987.   decode_ptr->isSet = TRUE;
  1988.   decode_ptr->isMem = FALSE;
  1989.   decode_ptr->memptr = NULL;
  1990.   decode_ptr->filename = filename;
  1991.   decode_ptr->ifile = fopen(filename, "r");
  1992.   if (decode_ptr->ifile == NULL) {
  1993.     free(decode_ptr);
  1994.     return (NULL);
  1995.   }
  1997.   return (decode_ptr);
  1998. }
  2000. void sdp_decode_info_free (sdp_decode_info_t *decode)
  2001. {
  2002.   if (decode->isMem == FALSE) {
  2003.     fclose(decode->ifile);
  2004.   }
  2005.   free(decode);
  2006. }