Ignore:
Timestamp:
Feb 19, 2006 1:38:06 AM (18 years ago)
Author:
bennylp
Message:

Initial SIMPLE implementation

File:
1 moved

Legend:

Unmodified
Added
Removed

  • pjproject/trunk/pjsip/src/pjsip-simple/evsub_msg.c

    • Property svn:keywords set to id
    r187 r197  
    1717 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  
    1818 */ 
    19 #include <pjsip_simple/event_notify_msg.h> 
    20 #include <pjsip/print.h> 
     19#include <pjsip-simple/evsub_msg.h> 
     20#include <pjsip/print_util.h> 
    2121#include <pjsip/sip_parser.h> 
    2222#include <pj/pool.h> 
    … …  
    2424#include <pj/except.h> 
    2525 
     26/* 
     27 * Event header. 
     28 */ 
    2629static int pjsip_event_hdr_print( pjsip_event_hdr *hdr,  
    2730                                  char *buf, pj_size_t size); 
    … …  
    4144PJ_DEF(pjsip_event_hdr*) pjsip_event_hdr_create(pj_pool_t *pool) 
    4245{ 
    43     pj_str_t event = { "Event", 5 }; 
    44     pjsip_event_hdr *hdr = pj_pool_calloc(pool, 1, sizeof(*hdr)); 
     46    pjsip_event_hdr *hdr = pj_pool_zalloc(pool, sizeof(*hdr)); 
    4547    hdr->type = PJSIP_H_OTHER; 
    46     hdr->name = hdr->sname = event; 
     48    hdr->name.ptr = "Event"; 
     49    hdr->name.slen = 5; 
     50    hdr->sname.ptr = "o"; 
     51    hdr->sname.slen = 1; 
    4752    hdr->vptr = &event_hdr_vptr; 
    4853    pj_list_init(hdr); 
     54    pj_list_init(&hdr->other_param); 
    4955    return hdr; 
    5056} 
    … …  
    6369    copy_advance(p, hdr->event_type); 
    6470    copy_advance_pair(p, ";id=", 4, hdr->id_param); 
    65     if (hdr->other_param.slen) 
    66         copy_advance(p, hdr->other_param); 
     71     
     72    printed = pjsip_param_print_on(&hdr->other_param, p, endbuf-p, 
     73                                   &pjsip_PARAM_CHAR_SPEC,  
     74                                   &pjsip_PARAM_CHAR_SPEC, ';'); 
     75    if (printed < 0) 
     76        return printed; 
     77 
     78    p += printed; 
    6779    return p - buf; 
    6880} 
    … …  
    7486    pj_strdup(pool, &hdr->event_type, &rhs->event_type); 
    7587    pj_strdup(pool, &hdr->id_param, &rhs->id_param); 
    76     pj_strdup(pool, &hdr->other_param, &rhs->other_param); 
    77     return hdr; 
    78 } 
    79  
    80 static pjsip_event_hdr* pjsip_event_hdr_shallow_clone( pj_pool_t *pool, 
    81                                                        const pjsip_event_hdr *rhs ) 
     88    pjsip_param_clone(pool, &hdr->other_param, &rhs->other_param); 
     89    return hdr; 
     90} 
     91 
     92static pjsip_event_hdr*  
     93pjsip_event_hdr_shallow_clone( pj_pool_t *pool, 
     94                               const pjsip_event_hdr *rhs ) 
    8295{ 
    8396    pjsip_event_hdr *hdr = pj_pool_alloc(pool, sizeof(*hdr)); 
    8497    pj_memcpy(hdr, rhs, sizeof(*hdr)); 
    85     return hdr; 
    86 } 
    87  
    88  
    89 static int pjsip_allow_events_hdr_print(pjsip_allow_events_hdr *hdr,  
    90                                         char *buf, pj_size_t size); 
    91 static pjsip_allow_events_hdr*  
    92 pjsip_allow_events_hdr_clone(pj_pool_t *pool,  
    93                              const pjsip_allow_events_hdr *hdr); 
    94 static pjsip_allow_events_hdr*  
    95 pjsip_allow_events_hdr_shallow_clone(pj_pool_t *pool, 
    96                                      const pjsip_allow_events_hdr*); 
    97  
    98 static pjsip_hdr_vptr allow_event_hdr_vptr =  
    99 { 
    100     (pjsip_hdr_clone_fptr) &pjsip_allow_events_hdr_clone, 
    101     (pjsip_hdr_clone_fptr) &pjsip_allow_events_hdr_shallow_clone, 
    102     (pjsip_hdr_print_fptr) &pjsip_allow_events_hdr_print, 
    103 }; 
    104  
    105  
     98    pjsip_param_shallow_clone(pool, &hdr->other_param, &rhs->other_param); 
     99    return hdr; 
     100} 
     101 
     102 
     103/* 
     104 * Allow-Events header. 
     105 */ 
    106106PJ_DEF(pjsip_allow_events_hdr*) pjsip_allow_events_hdr_create(pj_pool_t *pool) 
    107107{ 
    108     pj_str_t allow_events = { "Allow-Events", 12 }; 
    109     pjsip_allow_events_hdr *hdr = pj_pool_calloc(pool, 1, sizeof(*hdr)); 
    110     hdr->type = PJSIP_H_OTHER; 
    111     hdr->name = hdr->sname = allow_events; 
    112     hdr->vptr = &allow_event_hdr_vptr; 
    113     pj_list_init(hdr); 
    114     return hdr; 
    115 } 
    116  
    117 static int pjsip_allow_events_hdr_print(pjsip_allow_events_hdr *hdr,  
    118                                         char *buf, pj_size_t size) 
    119 { 
    120     char *p = buf; 
    121     char *endbuf = buf+size; 
    122     int printed; 
    123  
    124     copy_advance(p, hdr->name); 
    125     *p++ = ':'; 
    126     *p++ = ' '; 
    127  
    128     if (hdr->event_cnt > 0) { 
    129         int i; 
    130         copy_advance(p, hdr->events[0]); 
    131         for (i=1; i<hdr->event_cnt; ++i) { 
    132             copy_advance_pair(p, ",", 1, hdr->events[i]); 
    133         } 
    134     } 
    135  
    136     return p - buf; 
    137 } 
    138  
    139 static pjsip_allow_events_hdr*  
    140 pjsip_allow_events_hdr_clone(pj_pool_t *pool,  
    141                              const pjsip_allow_events_hdr *rhs) 
    142 { 
    143     int i; 
    144  
    145     pjsip_allow_events_hdr *hdr = pjsip_allow_events_hdr_create(pool); 
    146     hdr->event_cnt = rhs->event_cnt; 
    147     for (i=0; i<rhs->event_cnt; ++i) { 
    148         pj_strdup(pool, &hdr->events[i], &rhs->events[i]); 
    149     } 
    150     return hdr; 
    151 } 
    152  
    153 static pjsip_allow_events_hdr*  
    154 pjsip_allow_events_hdr_shallow_clone(pj_pool_t *pool, 
    155                                      const pjsip_allow_events_hdr *rhs) 
    156 { 
    157     pjsip_allow_events_hdr *hdr = pj_pool_alloc(pool, sizeof(*hdr)); 
    158     pj_memcpy(hdr, rhs, sizeof(*hdr)); 
    159     return hdr; 
    160 } 
    161  
    162  
     108    const pj_str_t STR_ALLOW_EVENTS = { "Allow-Events", 12}; 
     109    pjsip_allow_events_hdr *hdr; 
     110 
     111    hdr = pjsip_generic_array_hdr_create(pool, &STR_ALLOW_EVENTS); 
     112 
     113    if (hdr) { 
     114        hdr->sname.ptr = "u"; 
     115        hdr->sname.slen = 1; 
     116    } 
     117 
     118    return hdr; 
     119} 
     120 
     121 
     122/* 
     123 * Subscription-State header. 
     124 */ 
    163125static int pjsip_sub_state_hdr_print(pjsip_sub_state_hdr *hdr,  
    164126                                     char *buf, pj_size_t size); 
    … …  
    181143{ 
    182144    pj_str_t sub_state = { "Subscription-State", 18 }; 
    183     pjsip_sub_state_hdr *hdr = pj_pool_calloc(pool, 1, sizeof(*hdr)); 
     145    pjsip_sub_state_hdr *hdr = pj_pool_zalloc(pool, sizeof(*hdr)); 
    184146    hdr->type = PJSIP_H_OTHER; 
    185147    hdr->name = hdr->sname = sub_state; 
    … …  
    188150    hdr->retry_after = -1; 
    189151    pj_list_init(hdr); 
     152    pj_list_init(&hdr->other_param); 
    190153    return hdr; 
    191154} 
    … …  
    216179        p += printed; 
    217180    } 
    218     if (hdr->other_param.slen) 
    219         copy_advance(p, hdr->other_param); 
     181     
     182    printed = pjsip_param_print_on( &hdr->other_param, p, endbuf-p,  
     183                                    &pjsip_PARAM_CHAR_SPEC, 
     184                                    &pjsip_PARAM_CHAR_SPEC, 
     185                                    ';'); 
     186    if (printed < 0) 
     187        return printed; 
     188 
     189    p += printed; 
    220190 
    221191    return p - buf; 
    … …  
    231201    hdr->retry_after = rhs->retry_after; 
    232202    hdr->expires_param = rhs->expires_param; 
    233     pj_strdup(pool, &hdr->other_param, &rhs->other_param); 
     203    pjsip_param_clone(pool, &hdr->other_param, &rhs->other_param); 
    234204    return hdr; 
    235205} 
    … …  
    241211    pjsip_sub_state_hdr *hdr = pj_pool_alloc(pool, sizeof(*hdr)); 
    242212    pj_memcpy(hdr, rhs, sizeof(*hdr)); 
    243     return hdr; 
    244 } 
    245  
    246 static pjsip_event_hdr *parse_hdr_event(pj_scanner *scanner,  
    247                                         pj_pool_t *pool) 
    248 { 
    249     pjsip_event_hdr *hdr = pjsip_event_hdr_create(pool); 
     213    pjsip_param_shallow_clone(pool, &hdr->other_param, &rhs->other_param); 
     214    return hdr; 
     215} 
     216 
     217 
     218/* 
     219 * Parse Event header. 
     220 */ 
     221static pjsip_hdr *parse_hdr_event(pjsip_parse_ctx *ctx) 
     222{ 
     223    pjsip_event_hdr *hdr = pjsip_event_hdr_create(ctx->pool); 
    250224    const pj_str_t id_param = { "id", 2 }; 
    251225 
    252     pj_scan_get(scanner, pjsip_TOKEN_SPEC, &hdr->event_type); 
    253  
    254     while (*scanner->current == ';') { 
     226    pj_scan_get(ctx->scanner, &pjsip_TOKEN_SPEC, &hdr->event_type); 
     227 
     228    while (*ctx->scanner->curptr == ';') { 
    255229        pj_str_t pname, pvalue; 
    256         pj_scan_get_char(scanner); 
    257         pjsip_parse_param_imp(scanner, &pname, &pvalue, 0); 
     230 
     231        pj_scan_get_char(ctx->scanner); 
     232        pjsip_parse_param_imp(ctx->scanner, ctx->pool, &pname, &pvalue, 0); 
     233 
    258234        if (pj_stricmp(&pname, &id_param)==0) { 
    259235            hdr->id_param = pvalue; 
    260236        } else { 
    261             pjsip_concat_param_imp(&hdr->other_param, pool, &pname, &pvalue, ';'); 
     237            pjsip_param *param = pj_pool_alloc(ctx->pool, sizeof(pjsip_param)); 
     238            param->name = pname; 
     239            param->value = pvalue; 
     240            pj_list_push_back(&hdr->other_param, param); 
    262241        } 
    263242    } 
    264     pjsip_parse_end_hdr_imp( scanner ); 
    265     return hdr; 
    266 } 
    267  
    268 static pjsip_allow_events_hdr *parse_hdr_allow_events(pj_scanner *scanner,  
    269                                                       pj_pool_t *pool) 
    270 { 
    271     pjsip_allow_events_hdr *hdr = pjsip_allow_events_hdr_create(pool); 
    272  
    273     pj_scan_get(scanner, pjsip_TOKEN_SPEC, &hdr->events[0]); 
    274     hdr->event_cnt = 1; 
    275  
    276     while (*scanner->current == ',') { 
    277         pj_scan_get_char(scanner); 
    278         pj_scan_get(scanner, pjsip_TOKEN_SPEC, &hdr->events[hdr->event_cnt++]); 
    279         if (hdr->event_cnt == PJSIP_MAX_ALLOW_EVENTS) { 
    280             PJ_THROW(PJSIP_SYN_ERR_EXCEPTION); 
    281         } 
    282     } 
    283  
    284     pjsip_parse_end_hdr_imp( scanner ); 
    285     return hdr; 
    286 } 
    287  
    288 static pjsip_sub_state_hdr *parse_hdr_sub_state(pj_scanner *scanner,  
    289                                                 pj_pool_t *pool) 
    290 { 
    291     pjsip_sub_state_hdr *hdr = pjsip_sub_state_hdr_create(pool); 
     243    pjsip_parse_end_hdr_imp( ctx->scanner ); 
     244    return (pjsip_hdr*)hdr; 
     245} 
     246 
     247/* 
     248 * Parse Subscription-State header. 
     249 */ 
     250static pjsip_hdr* parse_hdr_sub_state( pjsip_parse_ctx *ctx ) 
     251{ 
     252    pjsip_sub_state_hdr *hdr = pjsip_sub_state_hdr_create(ctx->pool); 
    292253    const pj_str_t reason = { "reason", 6 }, 
    293254                   expires = { "expires", 7 }, 
    294255                   retry_after = { "retry-after", 11 }; 
    295     pj_scan_get(scanner, pjsip_TOKEN_SPEC, &hdr->sub_state); 
    296  
    297     while (*scanner->current == ';') { 
     256    pj_scan_get(ctx->scanner, &pjsip_TOKEN_SPEC, &hdr->sub_state); 
     257 
     258    while (*ctx->scanner->curptr == ';') { 
    298259        pj_str_t pname, pvalue; 
    299260 
    300         pj_scan_get_char(scanner); 
    301         pjsip_parse_param_imp(scanner, &pname, &pvalue, 0); 
     261        pj_scan_get_char(ctx->scanner); 
     262        pjsip_parse_param_imp(ctx->scanner, ctx->pool, &pname, &pvalue, 0); 
     263 
    302264        if (pj_stricmp(&pname, &reason) == 0) { 
    303265            hdr->reason_param = pvalue; 
     266 
    304267        } else if (pj_stricmp(&pname, &expires) == 0) { 
    305268            hdr->expires_param = pj_strtoul(&pvalue); 
     269 
    306270        } else if (pj_stricmp(&pname, &retry_after) == 0) { 
    307271            hdr->retry_after = pj_strtoul(&pvalue); 
     272 
    308273        } else { 
    309             pjsip_concat_param_imp(&hdr->other_param, pool, &pname, &pvalue, ';'); 
     274            pjsip_param *param = pj_pool_alloc(ctx->pool, sizeof(pjsip_param)); 
     275            param->name = pname; 
     276            param->value = pvalue; 
     277            pj_list_push_back(&hdr->other_param, param); 
    310278        } 
    311279    } 
    312280 
    313     pjsip_parse_end_hdr_imp( scanner ); 
    314     return hdr; 
    315 } 
    316  
    317 PJ_DEF(void) pjsip_event_notify_init_parser(void) 
    318 { 
    319     pjsip_register_hdr_parser( "Event", NULL, (pjsip_parse_hdr_func*) &parse_hdr_event); 
    320     pjsip_register_hdr_parser( "Allow-Events", NULL, (pjsip_parse_hdr_func*) &parse_hdr_allow_events); 
    321     pjsip_register_hdr_parser( "Subscription-State", NULL, (pjsip_parse_hdr_func*) &parse_hdr_sub_state); 
    322 } 
     281    pjsip_parse_end_hdr_imp( ctx->scanner ); 
     282    return (pjsip_hdr*)hdr; 
     283} 
     284 
     285/* 
     286 * Register header parsers. 
     287 */ 
     288PJ_DEF(void) pjsip_evsub_init_parser(void) 
     289{ 
     290    pjsip_register_hdr_parser( "Event", NULL,  
     291                               &parse_hdr_event); 
     292 
     293    pjsip_register_hdr_parser( "Subscription-State", NULL,  
     294                               &parse_hdr_sub_state); 
     295} 
     296 
Note: See TracChangeset for help on using the changeset viewer.