sdp.h

Go to the documentation of this file.

/*
 * This file is part of the Sofia-SIP package
 *
 * Copyright (C) 2005 Nokia Corporation.
 *
 * Contact: Pekka Pessi <pekka.pessi@nokia-email.address.hidden>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 */

#ifndef SDP_H
#define SDP_H

#ifndef SU_ALLOC_H
#include <sofia-sip/su_alloc.h>
#endif
#ifndef SU_TYPES_H
#include <sofia-sip/su_types.h>
#endif

SOFIA_BEGIN_DECLS

typedef struct sdp_session_s     sdp_session_t;
typedef unsigned long            sdp_version_t;
typedef struct sdp_origin_s      sdp_origin_t;
typedef struct sdp_connection_s  sdp_connection_t;
typedef struct sdp_bandwidth_s   sdp_bandwidth_t;
typedef struct sdp_time_s        sdp_time_t;
typedef struct sdp_repeat_s      sdp_repeat_t;
typedef struct sdp_zone_s        sdp_zone_t;
typedef struct sdp_key_s         sdp_key_t;
typedef struct sdp_attribute_s   sdp_attribute_t;
typedef struct sdp_media_s       sdp_media_t;
typedef struct sdp_list_s        sdp_list_t;
typedef struct sdp_rtpmap_s      sdp_rtpmap_t;

typedef char const               sdp_text_t;

#define SDP_MIME_TYPE "application/sdp"

enum {
  SDP_CURRENT_VERSION = 0
};

struct sdp_session_s
{
  int                sdp_size;      
  sdp_session_t     *sdp_next;          
  sdp_version_t      sdp_version[1];    
  sdp_origin_t      *sdp_origin;    
  sdp_text_t        *sdp_subject;   
  sdp_text_t        *sdp_information;   
  sdp_text_t        *sdp_uri;       
  sdp_list_t        *sdp_emails;    
  sdp_list_t        *sdp_phones;    
  sdp_connection_t  *sdp_connection;    
  sdp_bandwidth_t   *sdp_bandwidths;    
  sdp_time_t        *sdp_time;      
  sdp_key_t         *sdp_key;           
  sdp_attribute_t   *sdp_attributes;    
  sdp_text_t        *sdp_charset;       
  sdp_media_t       *sdp_media;         
};

struct sdp_origin_s
{
  int               o_size;     
  sdp_text_t       *o_username;     
  uint64_t          o_id;       
  uint64_t          o_version;      
  sdp_connection_t *o_address;      
};

typedef enum
{
  sdp_net_x = 0,            
  sdp_net_in = 1                
} sdp_nettype_e;

typedef enum
{
  sdp_addr_x   = 0,         
  sdp_addr_ip4 = 1,         
  sdp_addr_ip6 = 2,         
} sdp_addrtype_e;

struct sdp_connection_s
{
  int               c_size;     
  sdp_connection_t *c_next;     
  sdp_nettype_e     c_nettype;      
  sdp_addrtype_e    c_addrtype;     
  sdp_text_t       *c_address;      
  unsigned          c_ttl : 8;      
  unsigned          c_mcast : 1;        
  unsigned : 0;
  unsigned          c_groups;       
};

typedef enum
{
  sdp_bw_x,             
  sdp_bw_ct,                
  sdp_bw_as,                
  sdp_bw_tias,              
  sdp_bw_rs,                
  sdp_bw_rr,                
} sdp_bandwidth_e;

struct sdp_bandwidth_s
{
  int              b_size;      
  sdp_bandwidth_t *b_next;      
  sdp_bandwidth_e  b_modifier;      
  sdp_text_t      *b_modifier_name;     
  unsigned long    b_value;     
};

struct sdp_time_s
{
  int            t_size;        
  sdp_time_t    *t_next;        
  unsigned long  t_start;       
  unsigned long  t_stop;        
  sdp_repeat_t  *t_repeat;      
  sdp_zone_t    *t_zone;        
};

struct sdp_repeat_s
{
  int           r_size;         
  int           r_number_of_offsets;    
  unsigned long r_interval;     
  unsigned long r_duration;     
  unsigned long r_offsets[1];           
};

struct sdp_zone_s
{
  int z_size;
  int z_number_of_adjustments;      
  struct {
    unsigned long z_at;         
    long          z_offset;     
  } z_adjustments[1];               
};

typedef enum {
  sdp_key_x,                
  sdp_key_clear,            
  sdp_key_base64,           
  sdp_key_uri,              
  sdp_key_prompt            
} sdp_key_method_e;

struct sdp_key_s
{
  int              k_size;      
  sdp_key_method_e k_method;        
  sdp_text_t      *k_method_name;   
  sdp_text_t      *k_material;      
};

struct sdp_attribute_s {
  int              a_size;      
  sdp_attribute_t *a_next;      
  sdp_text_t      *a_name;      
  sdp_text_t      *a_value;     
};

typedef enum
{
  sdp_media_x = 0,          
  sdp_media_any,                
  sdp_media_audio,          
  sdp_media_video,          
  sdp_media_application,        
  sdp_media_data,           
  sdp_media_control,            
  sdp_media_message,            
  sdp_media_image,          
  sdp_media_red,            
  sdp_media_text,           
} sdp_media_e;

typedef enum
{
  sdp_proto_x = 0,          
  sdp_proto_tcp = 6,            
  sdp_proto_udp = 17,           
  sdp_proto_rtp = 256,          
  sdp_proto_srtp = 257,         
  sdp_proto_udptl = 258,        
  sdp_proto_msrp =  259,        
  sdp_proto_msrps = 260,        
  sdp_proto_extended_srtp = 261, 
  sdp_proto_extended_rtp = 262, 
  sdp_proto_tls = 511,          
  sdp_proto_any = 512               
} sdp_proto_e;

typedef enum {
  sdp_inactive = 0,
  sdp_sendonly = 1,
  sdp_recvonly = 2,
  sdp_sendrecv = sdp_sendonly | sdp_recvonly
} sdp_mode_t;

struct sdp_media_s
{
  int               m_size;     
  sdp_media_t      *m_next;     
  sdp_session_t    *m_session;          
  sdp_media_e       m_type;     
  sdp_text_t       *m_type_name;    
  unsigned long     m_port;     
  unsigned long     m_number_of_ports;  
  sdp_proto_e       m_proto;        
  sdp_text_t       *m_proto_name;   
  sdp_list_t       *m_format;       
  sdp_rtpmap_t     *m_rtpmaps;      
  sdp_text_t       *m_information;  
  sdp_connection_t *m_connections;  
  sdp_bandwidth_t  *m_bandwidths;   
  sdp_key_t        *m_key;      
  sdp_attribute_t  *m_attributes;   
  void             *m_user;         
  unsigned          m_rejected : 1;
  /* sdp_mode_t */ unsigned m_mode : 2;
  unsigned          : 0;
};

struct sdp_list_s
{
  int              l_size;      
  sdp_list_t      *l_next;      
  sdp_text_t      *l_text;          
};

struct sdp_rtpmap_s {
  int            rm_size;       
  sdp_rtpmap_t  *rm_next;       
  sdp_text_t    *rm_encoding;       
  unsigned long  rm_rate;       
  sdp_text_t    *rm_params;     
  sdp_text_t    *rm_fmtp;           
  unsigned       rm_predef : 1;         
  unsigned       rm_pt : 7;     
  unsigned       rm_any : 1;            
  unsigned       :0;
};

SOFIAPUBVAR sdp_rtpmap_t const * const sdp_rtpmap_well_known[128];

SOFIAPUBFUN sdp_session_t *sdp_session_dup(su_home_t *, sdp_session_t const *);

SOFIAPUBFUN
sdp_origin_t    *sdp_origin_dup(su_home_t *, sdp_origin_t const *);

SOFIAPUBFUN
sdp_connection_t *sdp_connection_dup(su_home_t *, sdp_connection_t const *);

SOFIAPUBFUN
sdp_bandwidth_t  *sdp_bandwidth_dup(su_home_t *, sdp_bandwidth_t const *);

SOFIAPUBFUN
sdp_time_t       *sdp_time_dup(su_home_t *, sdp_time_t const *);

SOFIAPUBFUN
sdp_repeat_t     *sdp_repeat_dup(su_home_t *, sdp_repeat_t const *);

SOFIAPUBFUN
sdp_zone_t       *sdp_zone_dup(su_home_t *, sdp_zone_t const *);

SOFIAPUBFUN
sdp_key_t        *sdp_key_dup(su_home_t *, sdp_key_t const *);

SOFIAPUBFUN
sdp_attribute_t  *sdp_attribute_dup(su_home_t *, sdp_attribute_t const *);

SOFIAPUBFUN
sdp_media_t *sdp_media_dup(su_home_t *, sdp_media_t const *,
               sdp_session_t *);

SOFIAPUBFUN
sdp_media_t *sdp_media_dup_all(su_home_t *, sdp_media_t const *,
                   sdp_session_t *);

SOFIAPUBFUN
sdp_list_t       *sdp_list_dup(su_home_t *, sdp_list_t const *);

SOFIAPUBFUN
sdp_rtpmap_t     *sdp_rtpmap_dup(su_home_t *, sdp_rtpmap_t const *);

SOFIAPUBFUN int sdp_session_cmp(sdp_session_t const *a,
                sdp_session_t const *b);

SOFIAPUBFUN int sdp_origin_cmp(sdp_origin_t const *a,
                   sdp_origin_t const *b);

SOFIAPUBFUN int sdp_connection_cmp(sdp_connection_t const *,
                   sdp_connection_t const *b);

SOFIAPUBFUN int sdp_bandwidth_cmp(sdp_bandwidth_t const *a,
                  sdp_bandwidth_t const *b);

SOFIAPUBFUN int sdp_time_cmp(sdp_time_t const *a, sdp_time_t const *b);

/* Compare two repeat (r=) fields */
SOFIAPUBFUN int sdp_repeat_cmp(sdp_repeat_t const *a, sdp_repeat_t const *b);

/* Compare two zone (z=) fields */
SOFIAPUBFUN int sdp_zone_cmp(sdp_zone_t const *a, sdp_zone_t const *b);

SOFIAPUBFUN int sdp_key_cmp(sdp_key_t const *a, sdp_key_t const *b);

SOFIAPUBFUN int sdp_attribute_cmp(sdp_attribute_t const *,
                  sdp_attribute_t const *);

SOFIAPUBFUN int sdp_media_cmp(sdp_media_t const *, sdp_media_t const *);

SOFIAPUBFUN int sdp_rtpmap_cmp(sdp_rtpmap_t const *a, sdp_rtpmap_t const *b);

SOFIAPUBFUN int sdp_list_cmp(sdp_list_t const *a, sdp_list_t const *b);

SOFIAPUBFUN sdp_connection_t *sdp_media_connections(sdp_media_t const *m);

SOFIAPUBFUN int sdp_media_has_rtp(sdp_media_t const *m);

SOFIAPUBFUN void sdp_media_type(sdp_media_t *m, char const *s);

SOFIAPUBFUN void sdp_media_transport(sdp_media_t *m, char const *s);

SOFIAPUBFUN sdp_attribute_t  *sdp_attribute_find(sdp_attribute_t const *a,
                         char const *name);

SOFIAPUBFUN sdp_attribute_t *sdp_attribute_find2(sdp_attribute_t const *a,
                         sdp_attribute_t const *a2,
                         char const *name);

SOFIAPUBFUN sdp_mode_t sdp_attribute_mode(sdp_attribute_t const *a,
                      sdp_mode_t defmode);

SOFIAPUBFUN sdp_attribute_t *sdp_attribute_by_mode(su_home_t *,
                           sdp_mode_t mode);

SOFIAPUBFUN
sdp_attribute_t *sdp_attribute_mapped_find(sdp_attribute_t const *a,
                       char const *name,
                       int pt, char **return_result);

SOFIAPUBFUN void sdp_attribute_append(sdp_attribute_t **list,
                      sdp_attribute_t const *a);

SOFIAPUBFUN int sdp_attribute_replace(sdp_attribute_t **list,
                      sdp_attribute_t *a,
                      sdp_attribute_t **return_replaced);

SOFIAPUBFUN sdp_attribute_t *sdp_attribute_remove(sdp_attribute_t **list,
                          char const *name);

/* Return 1 if m= line struct matches with given type and name */
SOFIAPUBFUN unsigned sdp_media_match(sdp_media_t const *m,
                     sdp_media_e type,
                     sdp_text_t *type_name,
                     sdp_proto_e proto,
                     sdp_text_t *proto_name);

SOFIAPUBFUN unsigned sdp_media_match_with(sdp_media_t const *a,
                      sdp_media_t const *b);

SOFIAPUBFUN unsigned sdp_media_count(sdp_session_t const *sdp,
                     sdp_media_e type,
                     sdp_text_t *type_name,
                     sdp_proto_e proto,
                     sdp_text_t *proto_name);

SOFIAPUBFUN unsigned sdp_media_count_with(sdp_session_t const *sdp,
                      sdp_media_t const *m0);

SOFIAPUBFUN int sdp_media_uses_rtp(sdp_media_t const *m);

SOFIAPUBFUN int sdp_rtpmap_match(sdp_rtpmap_t const *, sdp_rtpmap_t const *);

SOFIAPUBFUN sdp_rtpmap_t *sdp_rtpmap_find_matching(sdp_rtpmap_t const *list,
                           sdp_rtpmap_t const *rm);

/* ======================================================================== */

enum sdp_parse_flags_e {
  sdp_f_strict = 1,
  sdp_f_anynet = 2,
  sdp_f_realloc = 4,
  sdp_f_all_rtpmaps = 8,
  sdp_f_print_prefix = 16,
  sdp_f_mode_0000 = 32,
  sdp_f_insane = 64,
  sdp_f_c_missing = 128,
  sdp_f_config = 256,
  sdp_f_mode_manual = 512,
  sdp_f_mode_always = 1024
};

typedef struct sdp_parser_s sdp_parser_t;
typedef sdp_parser_t  *sdp_parser;

SOFIAPUBFUN sdp_parser_t *sdp_parse(su_home_t *,
                    char const msg[], issize_t msgsize,
                    int flags);
SOFIAPUBFUN char const *sdp_parsing_error(sdp_parser_t *p);
SOFIAPUBFUN sdp_session_t *sdp_session(sdp_parser_t *p);
SOFIAPUBFUN void sdp_parser_free(sdp_parser_t *p);

SOFIAPUBFUN int sdp_sanity_check(sdp_parser_t *);

SOFIAPUBFUN su_home_t *sdp_parser_home(sdp_parser_t *);

/* ======================================================================== */

typedef struct sdp_printer_s sdp_printer_t;
typedef sdp_printer_t *sdp_printer;

SOFIAPUBFUN sdp_printer_t *sdp_print(su_home_t *, sdp_session_t const *,
                     char msgbuf[], isize_t maxmsgsize,
                     int flags);
SOFIAPUBFUN char const *sdp_printing_error(sdp_printer_t *p);
SOFIAPUBFUN char const *sdp_message(sdp_printer_t *p);
SOFIAPUBFUN isize_t sdp_message_size(sdp_printer_t *p);
SOFIAPUBFUN void sdp_printer_free(sdp_printer_t *p);

#define sdp_mapped_attribute_find sdp_attribute_mapped_find
#define sdp_free_parser  sdp_parser_free
#define sdp_free_printer sdp_printer_free

SOFIA_END_DECLS

#endif /* SDP_H */