/src/kamailio/src/core/parser/sdp/sdp_helpr_funcs.c

Source (jump to first uncovered line)
/*
 * SDP parser helpers
 *
 * Copyright (C) 2008-2009 SOMA Networks, INC.
 * Copyright (C) 2010 VoIP Embedded, Inc
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *  notice, this list of conditions and the following disclaimer in the
 *  documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE FREEBSD PROJECT ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
 * EVENT SHALL THE FREEBSD PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */


#include <stdlib.h>
#include "../../ut.h"
#include "../msg_parser.h"
#include "../parser_f.h"
#include "../parse_hname2.h"
#include "sdp.h"


static struct
{
  const char *s;
  int len;
  int is_rtp;
} sup_ptypes[] = {{.s = "rtp/avp", .len = 7, .is_rtp = 1},
    {.s = "udptl", .len = 5, .is_rtp = 0},
    {.s = "rtp/avpf", .len = 8, .is_rtp = 1},
    {.s = "rtp/savp", .len = 8, .is_rtp = 1},
    {.s = "rtp/savpf", .len = 9, .is_rtp = 1},
    {.s = "udp", .len = 3, .is_rtp = 0},
    {.s = "udp/bfcp", .len = 8, .is_rtp = 0},
    {.s = NULL, .len = 0, .is_rtp = 0}};


#define READ(val)                                                   \
  ((unsigned int)(*(val + 0)) + ((unsigned int)(*(val + 1)) << 8) \
      + ((unsigned int)(*(val + 2)) << 16)                    \
      + ((unsigned int)(*(val + 3)) << 24))
#define advance(_ptr, _n, _str, _error)           \
  do {                                          \
    if((_ptr) + (_n) > (_str).s + (_str).len) \
      goto _error;                          \
    (_ptr) = (_ptr) + (_n);                   \
  } while(0);
#define one_of_16(_x, _t)                                                     \
  (_x == _t[0] || _x == _t[15] || _x == _t[8] || _x == _t[2] || _x == _t[3] \
      || _x == _t[4] || _x == _t[5] || _x == _t[6] || _x == _t[7]       \
      || _x == _t[1] || _x == _t[9] || _x == _t[10] || _x == _t[11]     \
      || _x == _t[12] || _x == _t[13] || _x == _t[14])
#define one_of_8(_x, _t)                                                     \
  (_x == _t[0] || _x == _t[7] || _x == _t[1] || _x == _t[2] || _x == _t[3] \
      || _x == _t[4] || _x == _t[5] || _x == _t[6])

int get_mixed_part_delimiter(str *body, str *mp_delimiter)
{
  static unsigned int boun[16] = {0x6e756f62, 0x4e756f62, 0x6e556f62,
      0x4e556f62, 0x6e754f62, 0x4e754f62, 0x6e554f62, 0x4e554f62,
      0x6e756f42, 0x4e756f42, 0x6e556f42, 0x4e556f42, 0x6e754f42,
      0x4e754f42, 0x6e554f42, 0x4e554f42};
  static unsigned int dary[16] = {0x79726164, 0x59726164, 0x79526164,
      0x59526164, 0x79724164, 0x59724164, 0x79524164, 0x59524164,
      0x79726144, 0x59726144, 0x79526144, 0x59526144, 0x79724144,
      0x59724144, 0x79524144, 0x59524144};
  str str_type;
  unsigned int x;
  char *p;


  /* LM_DBG("<%.*s>\n",body->len,body->s); */
  p = str_type.s = body->s;
  str_type.len = body->len;
  while(*p != ';' && p < (body->s + body->len))
    advance(p, 1, str_type, error);
  p++;
  str_type.s = p;
  str_type.len = body->len - (p - body->s);
  /* LM_DBG("string to parse: <%.*s>\n",str_type.len,str_type.s); */
  /* skip spaces and tabs if any */
  while(*p == ' ' || *p == '\t')
    advance(p, 1, str_type, error);
  advance(p, 4, str_type, error);
  x = READ(p - 4);
  if(!one_of_16(x, boun))
    goto other;
  advance(p, 4, str_type, error);
  x = READ(p - 4);
  if(!one_of_16(x, dary))
    goto other;

  /* skip spaces and tabs if any */
  while(*p == ' ' || *p == '\t')
    advance(p, 1, str_type, error);
  if(*p != '=') {
    LM_ERR("parse error: no = found after boundary field\n");
    goto error;
  }
  advance(p, 1, str_type, error);
  while((*p == ' ' || *p == '\t') && p + 1 < str_type.s + str_type.len)
    advance(p, 1, str_type, error);
  mp_delimiter->len = str_type.len - (int)(p - str_type.s);
  mp_delimiter->s = p;
  /* check if the boundary value is enclosed in quotes */
  if(*p == '"' || *p == '\'') {
    if(mp_delimiter->s[mp_delimiter->len - 1] == *p) {
      mp_delimiter->s = p + 1;
      mp_delimiter->len -= 2;
      if(mp_delimiter->len <= 0) {
        LM_ERR("invalid boundary field value\n");
        goto error;
      }
    } else {
      LM_ERR("missing closing quote in boundary field value\n");
      goto error;
    }
  }
  return 1;

error:
  return -1;
other:
  LM_DBG("'boundary' parsing error\n");
  return -1;
}


/**
 * rfc4566:
 * a=rtpmap:<payload type> <encoding name>/<clock rate> [/<encoding parameters>]
 */
int extract_rtpmap(str *body, str *rtpmap_payload, str *rtpmap_encoding,
    str *rtpmap_clockrate, str *rtpmap_parmas)
{
  char *cp, *cp1;
  int len;

  if(strncasecmp(body->s, "a=rtpmap:", 9) != 0) {
    /*LM_DBG("We are not pointing to an a=rtpmap: attribute =>`%.*s'\n", body->len, body->s); */
    return -1;
  }

  cp1 = body->s;

  rtpmap_payload->s = cp1 + 9; /* skip `a=rtpmap:' */
  rtpmap_payload->len =
      eat_line(rtpmap_payload->s, body->s + body->len - rtpmap_payload->s)
      - rtpmap_payload->s;
  trim_len(rtpmap_payload->len, rtpmap_payload->s, *rtpmap_payload);
  len = rtpmap_payload->len;

  /* */
  cp = eat_token_end(
      rtpmap_payload->s, rtpmap_payload->s + rtpmap_payload->len);
  rtpmap_payload->len = cp - rtpmap_payload->s;
  if(rtpmap_payload->len <= 0 || cp == rtpmap_payload->s) {
    LM_ERR("no encoding in `a=rtpmap'\n");
    return -1;
  }
  len -= rtpmap_payload->len;
  rtpmap_encoding->s = cp;
  cp = eat_space_end(rtpmap_encoding->s, rtpmap_encoding->s + len);
  len -= cp - rtpmap_encoding->s;
  if(len <= 0 || cp == rtpmap_encoding->s) {
    LM_ERR("no encoding in `a=rtpmap:'\n");
    return -1;
  }

  rtpmap_encoding->s = cp;
  cp1 = (char *)ser_memmem(cp, "/", len, 1);
  if(cp1 == NULL) {
    LM_ERR("invalid encoding in `a=rtpmap' at [%.*s]\n", len, cp);
    return -1;
  }
  len -= cp1 - cp;
  rtpmap_encoding->len = cp1 - cp;

  cp = cp1 + 1; /* skip '/' */
  len--;
  rtpmap_clockrate->s = cp;
  cp1 = (char *)ser_memmem(cp, "/", len, 1);
  if(cp1 == NULL) {
    /* no encoding parameters */
    rtpmap_clockrate->len = len;
    rtpmap_parmas->s = NULL;
    rtpmap_parmas->len = 0;
    return 0;
  }
  rtpmap_clockrate->len = cp1 - cp;
  len -= cp1 - cp;
  rtpmap_parmas->s = cp1 + 1; /* skip '/' */
  rtpmap_parmas->len = len - 1;
  return 0;
}

int extract_fmtp(str *body, str *fmtp_payload, str *fmtp_string)
{
  char *cp, *cp1;
  int len;

  if(strncasecmp(body->s, "a=fmtp:", 7) != 0) {
    /*LM_DBG("We are not pointing to an a=fmtp: attribute =>`%.*s'\n", body->len, body->s); */
    return -1;
  }

  cp1 = body->s;

  fmtp_payload->s = cp1 + 7; /* skip `a=fmtp:' */
  fmtp_payload->len =
      eat_line(fmtp_payload->s, body->s + body->len - fmtp_payload->s)
      - fmtp_payload->s;
  trim_len(fmtp_payload->len, fmtp_payload->s, *fmtp_payload);
  len = fmtp_payload->len;

  /* */
  cp = eat_token_end(fmtp_payload->s, fmtp_payload->s + fmtp_payload->len);
  fmtp_payload->len = cp - fmtp_payload->s;
  if(fmtp_payload->len <= 0 || cp == fmtp_payload->s) {
    LM_ERR("no encoding in `a=fmtp:'\n");
    return -1;
  }
  len -= fmtp_payload->len;
  fmtp_string->s = cp;
  cp = eat_space_end(fmtp_string->s, fmtp_string->s + len);
  len -= cp - fmtp_string->s;
  if(len <= 0 || cp == fmtp_string->s) {
    LM_ERR("no encoding in `a=fmtp:'\n");
    return -1;
  }

  fmtp_string->s = cp;

  fmtp_string->len =
      eat_line(fmtp_string->s, body->s + body->len - fmtp_string->s)
      - fmtp_string->s;
  trim_len(fmtp_string->len, fmtp_string->s, *fmtp_string);

  return 0;
}


/**
 * Allocate a new ice attribute
 */
static inline sdp_ice_attr_t *add_sdp_ice(sdp_stream_cell_t *_stream)
{
  sdp_ice_attr_t *ice_attr;
  int len;

  len = sizeof(sdp_ice_attr_t);
  ice_attr = (sdp_ice_attr_t *)pkg_malloc(len);
  if(ice_attr == NULL) {
    PKG_MEM_ERROR;
    return NULL;
  }
  memset(ice_attr, 0, len);

  /* Insert the new ice attribute */
  ice_attr->next = _stream->ice_attr;
  _stream->ice_attr = ice_attr;
  _stream->ice_attrs_num++;

  return ice_attr;
}

static inline sdp_ice_opt_t *add_sdp_ice_opt(sdp_stream_cell_t *_stream)
{
  sdp_ice_opt_t *ice_opt;
  int len;

  len = sizeof(sdp_ice_opt_t);
  ice_opt = (sdp_ice_opt_t *)pkg_malloc(len);
  if(ice_opt == NULL) {
    PKG_MEM_ERROR;
    return NULL;
  }
  memset(ice_opt, 0, len);

  /* Insert the new ice option */
  ice_opt->next = _stream->ice_opt;
  _stream->ice_opt = ice_opt;
  _stream->ice_opt_num++;

  return ice_opt;
}

int extract_candidate(str *body, sdp_stream_cell_t *stream)
{
  char *space, *start;
  int len, fl;
  sdp_ice_attr_t *ice_attr;

  if((body->len < 12) || (strncasecmp(body->s, "a=candidate:", 12) != 0)) {
    /*LM_DBG("We are not pointing to an a=candidate: attribute =>`%.*s'\n", body->len, body->s); */
    return -1;
  }

  start = body->s + 12;
  len = body->len - 12;

  space = memchr(start, 32, len);
  if((space == NULL) || (space - start + 3 > len) || !isdigit(*(space + 1))) {
    LM_ERR("no component in `a=candidate'\n");
    return -1;
  }

  fl = space - start;

  start = space + 1;
  len = len - (space - start + 1);
  space = memchr(start, 32, len);
  if(space == NULL) {
    LM_ERR("no component in `a=candidate'\n");
    return -1;
  }

  ice_attr = add_sdp_ice(stream);
  if(ice_attr == NULL) {
    LM_ERR("failed to add ice attribute\n");
    return -1;
  }

  /* currently only foundation and component-id are parsed */
  /* if needed, parse more */
  ice_attr->foundation.s = body->s + 12;
  ice_attr->foundation.len = fl;
  ice_attr->component_id = strtol(start, (char **)NULL, 10);

  return 0;
}


/* generic method for attribute extraction
 * field must has format "a=attrname:" */
int extract_field(str *body, str *value, str field)
{
  if(strncmp(body->s, field.s, field.len < body->len ? field.len : body->len)
      != 0) {
    /*LM_DBG("We are not pointing to an %.* attribute =>`%.*s'\n", field.len, field.s, body->len, body->s); */
    return -1;
  }

  value->s = body->s + field.len; /* skip `a=attrname:' */
  value->len = eat_line(value->s, body->s + body->len - value->s) - value->s;
  trim_len(value->len, value->s, *value);

  return 0;
}

int extract_ice_option(str *body, sdp_stream_cell_t *stream)
{
  sdp_ice_opt_t *ice_opt;

  char *ptr_src;
  int max_options =
      10;   /* protection - max options can be listed in one line */
  int length = 0; /* each option length */

  /* a=ice-options: */
  if((body->len < 14) || (strncasecmp(body->s, ICE_OPTIONS, 14) != 0))
    return -1;

  ptr_src = body->s + 14;
  if(*ptr_src == 32)
    ptr_src++; /* if starts with a space, skip it */

  /* identify all existing ICE options, if they are listed in one row */
  while(*ptr_src && *ptr_src != '\r' && *ptr_src != '\n'
      && max_options-- > 0) {
    while(*ptr_src != 32 && *ptr_src && *ptr_src != '\r'
        && *ptr_src != '\n') {
      length++;
      ptr_src++;
    }

    ice_opt = add_sdp_ice_opt(stream);
    if(ice_opt == NULL) {
      LM_ERR("failed to add ice option\n");
      return -1;
    }

    ice_opt->option.s = ptr_src - length;
    ice_opt->option.len = length;
    trim_len(ice_opt->option.len, ice_opt->option.s, ice_opt->option);

    length = 0;
    if(*ptr_src == 32)
      ptr_src++; /* skip space */
  }

  return 0;
}

int extract_ptime(str *body, str *ptime)
{
  static const str field = str_init("a=ptime:");
  return extract_field(body, ptime, field);
}

int extract_accept_types(str *body, str *accept_types)
{
  static const str field = str_init("a=accept-types:");
  return extract_field(body, accept_types, field);
}

int extract_accept_wrapped_types(str *body, str *accept_wrapped_types)
{
  static const str field = str_init("a=accept-wrapped-types:");
  return extract_field(body, accept_wrapped_types, field);
}

int extract_max_size(str *body, str *max_size)
{
  static const str field = str_init("a=max-size:");
  return extract_field(body, max_size, field);
}

int extract_path(str *body, str *path)
{
  static const str field = str_init("a=path:");
  return extract_field(body, path, field);
}

int extract_rtcp(str *body, str *rtcp)
{
  static const str field = str_init("a=rtcp:");
  return extract_field(body, rtcp, field);
}

int extract_sendrecv_mode(str *body, str *sendrecv_mode, int *is_on_hold)
{
  char *cp1;

  cp1 = body->s;
  if(!((strncasecmp(cp1, "a=sendrecv", 10) == 0)
         || (strncasecmp(cp1, "a=recvonly", 10) == 0))) {
    if((strncasecmp(cp1, "a=inactive", 10) == 0)
        || (strncasecmp(cp1, "a=sendonly", 10) == 0)) {
      *is_on_hold = RFC3264_HOLD;
    } else {
      return -1;
    }
  }

  sendrecv_mode->s = body->s + 2; /* skip `a=' */
  sendrecv_mode->len =
      8; /* we know the length and therefore we don't need to overkill */
  /*
  sendrecv_mode->len = eat_line(sendrecv_mode->s, body->s + body->len -
    sendrecv_mode->s) - sendrecv_mode->s;
  trim_len(sendrecv_mode->len, sendrecv_mode->s, *sendrecv_mode);
  */

  return 0;
}

int extract_bwidth(str *body, str *bwtype, str *bwwitdth)
{
  char *cp, *cp1;
  int len;

  cp1 = NULL;
  for(cp = body->s; (len = body->s + body->len - cp) > 0;) {
    cp1 = (char *)ser_memmem(cp, "b=", len, 2);
    if(cp1 == NULL || cp1[-1] == '\n' || cp1[-1] == '\r')
      break;
    cp = cp1 + 2;
  }
  if(cp1 == NULL)
    return -1;

  bwtype->s = cp1 + 2;
  bwtype->len =
      eat_line(bwtype->s, body->s + body->len - bwtype->s) - bwtype->s;
  trim_len(bwtype->len, bwtype->s, *bwtype);

  cp = bwtype->s;
  len = bwtype->len;
  cp1 = (char *)ser_memmem(cp, ":", len, 1);
  len -= cp1 - cp;
  if(len <= 0) {
    LM_ERR("invalid encoding in `b=%.*s'\n", bwtype->len, bwtype->s);
    return -1;
  }
  bwtype->len = cp1 - cp;

  /* skip ':' */
  bwwitdth->s = cp1 + 1;
  bwwitdth->len = len - 1;

  return 0;
}

int extract_mediaip(str *body, str *mediaip, int *pf, char *line)
{
  char *cp, *cp1;
  int len;

  cp1 = NULL;
  for(cp = body->s; (len = body->s + body->len - cp) > 0;) {
    cp1 = (char *)ser_memmem(cp, line, len, 2);
    if(cp1 == NULL || cp1[-1] == '\n' || cp1[-1] == '\r')
      break;
    cp = cp1 + 2;
  }
  if(cp1 == NULL)
    return -1;

  mediaip->s = cp1 + 2;
  mediaip->len =
      eat_line(mediaip->s, body->s + body->len - mediaip->s) - mediaip->s;
  trim_len(mediaip->len, mediaip->s, *mediaip);
  if(mediaip->len == 0) {
    LM_ERR("no [%s] line in SDP\n", line);
    return -1;
  }

  /* search reverse for IP[4|6] in c=/o= line */
  cp = (char *)ser_memrmem(mediaip->s, " IP", mediaip->len, 3);
  if(cp == NULL) {
    LM_ERR("no `IP[4|6]' in `%s' field\n", line);
    return -1;
  }
  /* safety checks:
   * - for length, at least 6: ' IP[4|6] x...'
   * - white space after
   */
  if(cp + 6 > mediaip->s + mediaip->len && cp[4] != ' ') {
    LM_ERR("invalid content for `%s' line\n", line);
    return -1;
  }
  switch(cp[3]) {
    case '4':
      *pf = AF_INET;
      break;
    case '6':
      *pf = AF_INET6;
      break;
    default:
      LM_ERR("invalid addrtype IPx for `%s' line\n", line);
      return -1;
  }
  cp += 5;

  /* next token is the IP address */
  cp = eat_space_end(cp, mediaip->s + mediaip->len);
  len = eat_token_end(cp, mediaip->s + mediaip->len) - cp;
  mediaip->s = cp;
  mediaip->len = len;

  if(mediaip->len == 0) {
    LM_ERR("no `IP[4|6]' address in `%s' field\n", line);
    return -1;
  }

  LM_DBG("located IP address [%.*s] in `%s' field\n", mediaip->len,
      mediaip->s, line);
  return 1;
}

int extract_media_attr(str *body, str *mediamedia, str *mediaport,
    str *mediatransport, str *mediapayload, int *is_rtp)
{
  char *cp, *cp1;
  int len, i;

  cp1 = NULL;
  for(cp = body->s; (len = body->s + body->len - cp) > 0;) {
    cp1 = (char *)ser_memmem(cp, "m=", len, 2);
    if(cp1 == NULL || cp1[-1] == '\n' || cp1[-1] == '\r')
      break;
    cp = cp1 + 2;
  }
  if(cp1 == NULL) {
    LM_ERR("no `m=' in SDP\n");
    return -1;
  }
  mediaport->s = cp1 + 2; /* skip `m=' */
  mediaport->len = eat_line(mediaport->s, body->s + body->len - mediaport->s)
           - mediaport->s;
  trim_len(mediaport->len, mediaport->s, *mediaport);

  mediapayload->len = mediaport->len;
  mediamedia->s = mediaport->s;


  /* Skip media supertype and spaces after it */
  cp = eat_token_end(mediaport->s, mediaport->s + mediaport->len);
  mediaport->len -= cp - mediaport->s;
  mediamedia->len = mediapayload->len - mediaport->len;
  if(mediaport->len <= 0 || cp == mediaport->s) {
    LM_ERR("no port in `m='\n");
    return -1;
  }
  mediaport->s = cp;

  cp = eat_space_end(mediaport->s, mediaport->s + mediaport->len);
  mediaport->len -= cp - mediaport->s;
  if(mediaport->len <= 0 || cp == mediaport->s) {
    LM_ERR("no port in `m='\n");
    return -1;
  }

  /* Extract port */
  mediaport->s = cp;
  cp = eat_token_end(mediaport->s, mediaport->s + mediaport->len);
  mediatransport->len = mediaport->len - (cp - mediaport->s);
  if(mediatransport->len <= 0 || cp == mediaport->s) {
    LM_ERR("no port in `m='\n");
    return -1;
  }
  mediatransport->s = cp;
  mediaport->len = cp - mediaport->s;

  /* Skip spaces after port */
  cp = eat_space_end(
      mediatransport->s, mediatransport->s + mediatransport->len);
  mediatransport->len -= cp - mediatransport->s;
  if(mediatransport->len <= 0 || cp == mediatransport->s) {
    LM_ERR("no protocol type in `m='\n");
    return -1;
  }
  /* Extract protocol type */
  mediatransport->s = cp;
  cp = eat_token_end(
      mediatransport->s, mediatransport->s + mediatransport->len);
  if(cp == mediatransport->s) {
    LM_ERR("no protocol type in `m='\n");
    return -1;
  }
  mediatransport->len = cp - mediatransport->s;

  mediapayload->s = mediatransport->s + mediatransport->len;
  mediapayload->len -= mediapayload->s - mediamedia->s;
  cp = eat_space_end(mediapayload->s, mediapayload->s + mediapayload->len);
  mediapayload->len -= cp - mediapayload->s;
  mediapayload->s = cp;

  for(i = 0; sup_ptypes[i].s != NULL; i++)
    if(mediatransport->len == sup_ptypes[i].len
        && strncasecmp(mediatransport->s, sup_ptypes[i].s,
               mediatransport->len)
               == 0) {
      *is_rtp = sup_ptypes[i].is_rtp;
      return 0;
    }
  /* Unproxyable protocol type. Generally it isn't error. */
  return 0;
}

int extract_sess_version(str *oline, str *sess_version)
{

  char *cp0 = NULL;
  char *cp = NULL;
  int len = 0;
  char ws = ' ';
  int i = 0;

  /*
  "o=jdoe 2890844526 2890842807 IN IP4 10.47.16.5" CR LF
  "o=W 1 2 IN IP4 0.0.0.0" CR LF -> 24
  "o=W 1 2 IN IP6 ::1" CR LF -> 20
  "o=W 1 2 X Y Z" CR LF -> 15
  */
  if(oline->s == NULL || oline->len < 15) {
    LM_ERR("invalid o -line\n");
    return -1;
  }

  if(sess_version == NULL) {
    LM_ERR("invalid result pointer\n");
    return -1;
  }

  LM_DBG("oline(%d): >%.*s<\n", oline->len, oline->len, oline->s);

  // jump over o=
  cp = oline->s + 2;
  len = oline->len - 2;

  // find whitespace 3 times
  do {
    cp0 = cp;
    //LM_DBG("loop %d: >%.*s<\n", len, len, cp0);

    cp = (char *)ser_memmem(cp0, &ws, len, 1);
    if(cp == NULL) {
      break;
    }

    //LM_DBG("cp0: %p cp: %p (%ld)\n", cp0, cp, cp-cp0);
    len -= cp - cp0;

    // step over whitespace
    if(len > 0) {
      cp++;
      len--;
    }

    i++;
  } while(len < oline->len && i < 3);

  len = cp - cp0 - 1;
  LM_DBG("end %d: >%.*s<\n", len, len, cp0);

  sess_version->s = cp0;
  sess_version->len = len;

  if(!isdigit(*cp0)) {
    LM_WARN("not digit >%.*s<\n", len, cp0);
  }

  return 1;
}


/*
 * Auxiliary for some functions.
 * Returns pointer to first character of found line, or NULL if no such line.
 */

char *find_sdp_line(char *p, char *plimit, char linechar)
{
  static char linehead[3] = "x=";
  char *cp, *cp1;
  linehead[0] = linechar;
  /* Iterate through body */
  cp = p;
  for(;;) {
    if(cp >= plimit)
      return NULL;
    cp1 = ser_memmem(cp, linehead, plimit - cp, 2);
    if(cp1 == NULL)
      return NULL;
    /*
     * As it is body, we assume it has previous line and we can
     * lookup previous character.
     */
    if(cp1[-1] == '\n' || cp1[-1] == '\r')
      return cp1;
    /*
     * Having such data, but not at line beginning.
     * Skip them and reiterate. ser_memmem() will find next
     * occurrence.
     */
    if(plimit - cp1 < 2)
      return NULL;
    cp = cp1 + 2;
  }
}


/* This function assumes p points to a line of requested type. */
char *find_next_sdp_line(char *p, char *plimit, char linechar, char *defptr)
{
  char *t;
  if(p >= plimit || plimit - p < 3)
    return defptr;
  t = find_sdp_line(p + 2, plimit, linechar);
  return t ? t : defptr;
}


/* Find first SDP line starting with linechar. Return defptr if not found */
char *find_first_sdp_line(
    char *pstart, char *plimit, char linechar, char *defptr)
{
  char *t;
  if(pstart >= plimit || plimit - pstart < 3)
    return defptr;
  t = find_sdp_line(pstart, plimit, linechar);
  return t ? t : defptr;
}


/* returns pointer to next header line, and fill hdr_f ;
 * if at end of header returns pointer to the last crlf  (always buf)*/
char *get_sdp_hdr_field(char *buf, char *end, struct hdr_field *hdr)
{

  char *tmp;
  char *match;

  if((*buf) == '\n' || (*buf) == '\r') {
    /* double crlf or lflf or crcr */
    hdr->type = HDR_EOH_T;
    return buf;
  }

  tmp = parse_hname2(buf, end, hdr);
  if(hdr->type == HDR_ERROR_T) {
    LM_ERR("bad header\n");
    goto error;
  }

  /* eliminate leading whitespace */
  tmp = eat_lws_end(tmp, end);
  if(tmp >= end) {
    LM_ERR("hf empty\n");
    goto error;
  }

  /* just skip over it */
  hdr->body.s = tmp;
  /* find end of header */
  /* find lf */
  do {
    match = memchr(tmp, '\n', end - tmp);
    if(match) {
      match++;
    } else {
      LM_ERR("bad body for <%.*s>(%d)\n", hdr->name.len, hdr->name.s,
          hdr->type);
      tmp = end;
      goto error;
    }
    tmp = match;
  } while(match < end && ((*match == ' ') || (*match == '\t')));
  tmp = match;
  hdr->body.len = match - hdr->body.s;

  /* jku: if \r covered by current length, shrink it */
  trim_r(hdr->body);
  hdr->len = tmp - hdr->name.s;
  return tmp;
error:
  LM_DBG("error exit\n");
  hdr->type = HDR_ERROR_T;
  hdr->len = tmp - hdr->name.s;
  return tmp;
}


char *find_sdp_line_delimiter(char *p, char *plimit, str delimiter)
{
  static char delimiterhead[3] = "--";
  char *cp, *cp1;
  /* Iterate through body */
  cp = p;
  for(;;) {
    if(cp >= plimit)
      return NULL;
    for(;;) {
      cp1 = ser_memmem(cp, delimiterhead, plimit - cp, 2);
      if(cp1 == NULL)
        return NULL;
      /* We matched '--',
       * now let's match the boundary delimiter */
      if(cp1 + 2 + delimiter.len >= plimit)
        return NULL;
      if(strncmp(cp1 + 2, delimiter.s, delimiter.len) == 0)
        break;
      else
        cp = cp1 + 2 + delimiter.len;
    }
    if(cp1[-1] == '\n' || cp1[-1] == '\r')
      return cp1;
    if(plimit - cp1 < 2 + delimiter.len)
      return NULL;
    cp = cp1 + 2 + delimiter.len;
  }
}


/*
 * This function assumes p points to a delimiter type line.
 */
char *find_next_sdp_line_delimiter(
    char *p, char *plimit, str delimiter, char *defptr)
{
  char *t;
  if(p >= plimit || plimit - p < 3)
    return defptr;
  t = find_sdp_line_delimiter(p + 2, plimit, delimiter);
  return t ? t : defptr;
}

Coverage Report

Created: 2024-02-25 06:34