parse_sst.c

Go to the documentation of this file.

/*
 * $Id$
 * 
 * Copyright (c) 2006 SOMA Networks, Inc. <http://www.somanetworks.com/>
 *
 * This file is part of Kamailio, a free SIP server.
 *
 * Kamailio is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version
 *
 * Kamailio 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License 
 * along with this program; if not, write to the Free Software 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * History:
 * --------
 * 2006-02-17 Initial revision (dhsueh@somanetworks.com)
 */

#include "parse_sst.h"

#include "../../error.h"
#include "../../dprint.h"
#include "../../mem/mem.h"


inline int/*bool*/  is_space( char c ) { return (c == ' ' || c == '\t'); }
inline int/*bool*/  is_num( char c ) { return (c >= '0' && c <= '9'); }

inline unsigned  lower_byte( char b ) { return b | 0x20; }
inline unsigned  lower_4bytes( unsigned d ) { return d | 0x20202020; }
inline unsigned  lower_3bytes( unsigned d ) { return d |   0x202020; }
inline unsigned  read_4bytes( char *val ) {
        return (*(val + 0) + (*(val + 1) << 8)
                + (*(val + 2) << 16) + (*(val + 3) << 24));
}
inline unsigned  read_3bytes( char *val ) {
        return (*(val + 0) + (*(val + 1) << 8) + (*(val + 2) << 16));
}

/* compile-time constants if called with constants */
#define  MAKE_4BYTES( a, b, c, d ) \
        ( ((a)&0xFF) | (((b)&0xFF)<<8) | (((c)&0xFF)<<16) | (((d)&0xFF)<<24) )
#define  MAKE_3BYTES( a, b, c ) \
        ( ((a)&0xFF) | (((b)&0xFF)<<8) | (((c)&0xFF)<<16) )


struct session_expires *
malloc_session_expires( void )
{
        struct session_expires *se = (struct session_expires *)
                pkg_malloc( sizeof(struct session_expires) );
        if ( se )
                memset( se, 0, sizeof(struct session_expires) );
        return se;
}

void hf_free_session_expires(void *parsed)
{
        struct session_expires *se;
        se = (struct session_expires*)parsed;
        free_session_expires(se);
}


void
free_session_expires( struct session_expires *se )
{
        if ( se )
                pkg_free( se );
}


enum parse_sst_result
parse_session_expires_body( struct hdr_field *hf )
{
        register char *p = hf->body.s;
        int pos = 0;
        int len = hf->body.len;
        char *q;
        struct session_expires se = { 0, 0, sst_refresher_unspecified };
        unsigned tok;

        if ( !p || len <= 0 ) {
                LM_ERR(" no body for header field\n" );
                return parse_sst_header_not_found;
        }

        /* skip whitespace */
        for ( ; pos < len && is_space(*p); ++pos, ++p )
                /*nothing*/;

        /* collect a number */
        for ( q = p; pos < len && is_num(*q); ++pos, ++q )
                se.interval = se.interval*10/*radix*/ + (*q - '0');

        if ( q == p ) /*nothing parsed */ {
                LM_ERR(" no expiry interval\n" );
                return parse_sst_no_value;
        }
        p = q;

        /* continue on with params */
        while ( pos < len ) {

                if ( *p == ';' ) {
                        ++p; ++pos;

                        if ( pos + 4 < len ) {
                                switch ( lower_4bytes(read_4bytes(p)) ) {
                                        case /*refr*/MAKE_4BYTES('r','e','f','r'):
                                                if ( pos + 9 <= len
                                                         && lower_4bytes(read_4bytes(p+4))
                                                                == /*eshe*/MAKE_4BYTES('e','s','h','e')
                                                         && lower_byte(*(p+8)) == 'r'
                                                         && *(p+9) == '=' ) {
                                                        tok = lower_3bytes( read_3bytes(p+10) );
                                                        if ( tok == MAKE_3BYTES('u','a','c') ) {
                                                                se.refresher = sst_refresher_uac;
                                                                p += 13; pos += 13;
                                                        }
                                                        else if ( tok == MAKE_3BYTES('u','a','s') ) {
                                                                se.refresher = sst_refresher_uas;
                                                                p += 13; pos += 13;
                                                        }
                                                        else /* unrecognized refresher-param */ {
                                                                LM_ERR(" unrecognized refresher\n" );
                                                                return parse_sst_parse_error;
                                                        }
                                                }
                                                else /* not "esher=" */ {
                                                        /* there are no other se-params 
                                                           that start with "refr" */
                                                        for ( ; pos < len && *p != ';'; ++pos, ++p )
                                                                /*skip to ';'*/;
                                                }
                                                break;
                                        default:
                                                /* unrecognized se-param */
                                                for ( ; pos < len && *p != ';'; ++pos, ++p )
                                                        /*skip to ';'*/;
                                                break;
                                } /*switch*/
                        } /* exist 4 bytes to check */
                        else /* less than 4 bytes left */ {
                                /* not enough text left for any of the recognized se-params */
                                /* no other recognized se-param */
                                for ( ; pos < len && *p != ';'; ++pos, ++p ) /*skip to ';'*/;
                        }
                }
                else /* not ';' */ {
                        LM_ERR("no semicolon separating se-params\n");
                        return parse_sst_parse_error;
                } /* if ';' */
        } /* while */

        hf->parsed = malloc_session_expires();
        if ( !hf->parsed ) {
                LM_ERR(" out of pkg memory\n" );
                return parse_sst_out_of_mem;
        }
        se.hfree = hf_free_session_expires;
        *((struct session_expires *)hf->parsed) = se;

        return parse_sst_success;
}


enum parse_sst_result
parse_session_expires( struct sip_msg *msg, struct session_expires *se )
{
        enum parse_sst_result result;

        if ( msg->session_expires ) {
                if ( msg->session_expires->parsed == 0
                         && (result = parse_session_expires_body(msg->session_expires))
                                != parse_sst_success ) {
                        return result;
                }
                if ( se ) {
                        *se = *((struct session_expires *)msg->session_expires->parsed);
                }
                return parse_sst_success;
        }
        else {
                return parse_sst_header_not_found;
        }
}


enum parse_sst_result
parse_min_se_body( struct hdr_field *hf )
{
        int len = hf->body.len;
        char *p = hf->body.s;
        int pos = 0;
        unsigned int interval = 0;

        /* skip whitespace */
        for ( ; pos < len && is_space(*p); ++pos, ++p )
                /*nothing*/;
        if ( pos == len )
                return parse_sst_no_value;
        /* collect a number */
        for ( ; pos < len && is_num(*p); ++pos, ++p )
                interval = interval*10/*radix*/ + (*p - '0');
        /* skip whitespace */
        for ( ; pos < len && is_space(*p); ++pos, ++p )
                /*nothing*/;
        if ( pos != len ) /* shouldn't be any more junk */
                return parse_sst_parse_error;
        hf->parsed=(void*)(long)interval;
        return parse_sst_success;
}


enum parse_sst_result
parse_min_se( struct sip_msg *msg, unsigned int *min_se )
{
        enum parse_sst_result result;

        if ( msg->min_se ) {
                if ( msg->min_se->parsed == 0
                         && (result = parse_min_se_body(msg->min_se))
                                != parse_sst_success ) {
                        return result;
                }
                if ( min_se ) {
                        *min_se = (unsigned int)(long)msg->min_se->parsed;
                }
                return parse_sst_success;
        }
        else {
                return parse_sst_header_not_found;
        }
}