Changeset 3241


Ignore:
Timestamp:
Aug 1, 2010 9:24:58 AM (10 years ago)
Author:
bennylp
Message:

Re #1070 (support for multipart bodies): modified the param field of pjsip_media_type from a simple string to pjsip_param, to support a more complex use of this field

Location:
pjproject/trunk/pjsip
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • pjproject/trunk/pjsip/include/pjsip/sip_msg.h

    r3233 r3241  
    516516    pj_str_t type;          /**< Media type. */ 
    517517    pj_str_t subtype;       /**< Media subtype. */ 
    518     pj_str_t param;         /**< Media type parameters (concatenated). */ 
     518    pjsip_param param;      /**< Media type parameters */ 
    519519} pjsip_media_type; 
    520520 
     521 
     522/** 
     523 * Initialize the media type with the specified type and subtype string. 
     524 * 
     525 * @param mt            The media type. 
     526 * @param type          Optionally specify the media type. 
     527 * @param subtype       Optionally specify the media subtype. 
     528 */ 
     529PJ_DECL(void) pjsip_media_type_init(pjsip_media_type *mt, 
     530                                    pj_str_t *type, 
     531                                    pj_str_t *subtype); 
     532 
     533/** 
     534 * Initialize the media type with the specified type and subtype string. 
     535 * 
     536 * @param mt            The media type. 
     537 * @param type          Optionally specify the media type. 
     538 * @param subtype       Optionally specify the media subtype. 
     539 */ 
     540PJ_DECL(void) pjsip_media_type_init2(pjsip_media_type *mt, 
     541                                     char *type, 
     542                                     char *subtype); 
     543 
     544/** 
     545 * Compare two media types. 
     546 * 
     547 * @param mt1           The first media type. 
     548 * @param mt2           The second media type. 
     549 * 
     550 * @return              Zero if both media types are equal, -1 if mt1 < mt2, 
     551 *                      1 if mt1 > mt2. 
     552 */ 
     553PJ_DECL(int) pjsip_media_type_cmp(const pjsip_media_type *mt1, 
     554                                  const pjsip_media_type *mt2); 
    521555 
    522556/** 
     
    530564                                  pjsip_media_type *dst, 
    531565                                  const pjsip_media_type *src); 
     566 
     567/** 
     568 * Print media type to the specified buffer. 
     569 * 
     570 * @param buf           Destination buffer. 
     571 * @param len           Length of the buffer. 
     572 * @param mt            The media type to be printed. 
     573 * 
     574 * @return              The number of characters printed to the buffer, or -1 
     575 *                      if there's not enough space in the buffer. 
     576 */ 
     577PJ_DECL(int) pjsip_media_type_print(char *buf, unsigned len, 
     578                                    const pjsip_media_type *mt); 
    532579 
    533580/** 
  • pjproject/trunk/pjsip/src/pjsip-ua/sip_xfer.c

    r2750 r3241  
    375375    pjsip_tx_data *tdata; 
    376376    pjsip_xfer *xfer; 
     377    pjsip_param *param; 
    377378    const pj_str_t reason = { "noresource", 10 }; 
    378379    char *body; 
     
    423424    /* Create SIP message body. */ 
    424425    msg_body = PJ_POOL_ZALLOC_T(tdata->pool, pjsip_msg_body); 
    425     msg_body->content_type.type = STR_MESSAGE; 
    426     msg_body->content_type.subtype = STR_SIPFRAG; 
    427     msg_body->content_type.param = STR_SIPFRAG_VERSION; 
     426    pjsip_media_type_init(&msg_body->content_type, (pj_str_t*)&STR_MESSAGE, 
     427                          (pj_str_t*)&STR_SIPFRAG); 
    428428    msg_body->data = body; 
    429429    msg_body->len = bodylen; 
    430430    msg_body->print_body = &pjsip_print_text_body; 
    431431    msg_body->clone_data = &pjsip_clone_text_data; 
     432 
     433    param = PJ_POOL_ALLOC_T(tdata->pool, pjsip_param); 
     434    param->name = pj_str("version"); 
     435    param->value = pj_str("2.0"); 
     436    pj_list_push_back(&msg_body->content_type.param, param); 
    432437 
    433438    /* Attach sipfrag body. */ 
  • pjproject/trunk/pjsip/src/pjsip/sip_msg.c

    r2968 r3241  
    2323#include <pjsip/sip_errno.h> 
    2424#include <pj/ctype.h> 
     25#include <pj/guid.h> 
    2526#include <pj/string.h> 
    2627#include <pj/pool.h> 
     
    146147 
    147148static pj_str_t status_phrase[710]; 
    148 static int print_media_type(char *buf, const pjsip_media_type *media); 
     149static int print_media_type(char *buf, unsigned len, 
     150                            const pjsip_media_type *media); 
    149151 
    150152static int init_status_phrase() 
     
    490492 
    491493            /* Add Content-Type header. */ 
    492             if ( (end-p) < 24 + media->type.slen + media->subtype.slen +  
    493                            media->param.slen)  
    494             { 
     494            if ( (end-p) < 24 + media->type.slen + media->subtype.slen) { 
    495495                return -1; 
    496496            } 
    497497            pj_memcpy(p, ctype_hdr.ptr, ctype_hdr.slen); 
    498498            p += ctype_hdr.slen; 
    499             p += print_media_type(p, media); 
     499            p += print_media_type(p, end-p, media); 
    500500            *p++ = '\r'; 
    501501            *p++ = '\n'; 
     
    603603 * Media type 
    604604 */ 
     605/* 
     606 * Init media type. 
     607 */ 
     608PJ_DEF(void) pjsip_media_type_init( pjsip_media_type *mt, 
     609                                    pj_str_t *type, 
     610                                    pj_str_t *subtype) 
     611{ 
     612    pj_bzero(mt, sizeof(*mt)); 
     613    pj_list_init(&mt->param); 
     614    if (type) 
     615        mt->type = *type; 
     616    if (subtype) 
     617        mt->subtype = *subtype; 
     618} 
     619 
     620PJ_DEF(void) pjsip_media_type_init2( pjsip_media_type *mt, 
     621                                     char *type, 
     622                                     char *subtype) 
     623{ 
     624    pj_str_t s_type, s_subtype; 
     625 
     626    if (type) { 
     627        s_type = pj_str(type); 
     628    } else { 
     629        s_type.ptr = NULL; 
     630        s_type.slen = 0; 
     631    } 
     632 
     633    if (subtype) { 
     634        s_subtype = pj_str(subtype); 
     635    } else { 
     636        s_subtype.ptr = NULL; 
     637        s_subtype.slen = 0; 
     638    } 
     639 
     640    pjsip_media_type_init(mt, &s_type, &s_subtype); 
     641} 
     642 
     643/* 
     644 * Compare two media types. 
     645 */ 
     646PJ_DEF(int) pjsip_media_type_cmp( const pjsip_media_type *mt1, 
     647                                  const pjsip_media_type *mt2) 
     648{ 
     649    int rc; 
     650 
     651    PJ_ASSERT_RETURN(mt1 && mt2, 1); 
     652 
     653    rc = pj_stricmp(&mt1->type, &mt2->type); 
     654    if (rc) return rc; 
     655 
     656    rc = pj_stricmp(&mt1->subtype, &mt2->subtype); 
     657    if (rc) return rc; 
     658 
     659    rc = pjsip_param_cmp(&mt1->param, &mt2->param, 0); 
     660 
     661    return rc; 
     662} 
     663 
    605664PJ_DEF(void) pjsip_media_type_cp( pj_pool_t *pool, 
    606665                                  pjsip_media_type *dst, 
     
    610669    pj_strdup(pool, &dst->type,    &src->type); 
    611670    pj_strdup(pool, &dst->subtype, &src->subtype); 
    612     pj_strdup(pool, &dst->param,  &src->param); 
     671    pjsip_param_clone(pool, &dst->param, &src->param); 
    613672} 
    614673 
     
    12641323    pj_bzero(mem, sizeof(pjsip_ctype_hdr)); 
    12651324    init_hdr(hdr, PJSIP_H_CONTENT_TYPE, &ctype_hdr_vptr); 
     1325    pj_list_init(&hdr->media.param); 
    12661326    return hdr; 
    12671327 
     
    12741334} 
    12751335 
    1276 static int print_media_type(char *buf, const pjsip_media_type *media) 
     1336static int print_media_type(char *buf, unsigned len, 
     1337                            const pjsip_media_type *media) 
    12771338{ 
    12781339    char *p = buf; 
     1340    pj_ssize_t printed; 
     1341    const pjsip_parser_const_t *pc; 
    12791342 
    12801343    pj_memcpy(p, media->type.ptr, media->type.slen); 
     
    12841347    p += media->subtype.slen; 
    12851348 
    1286     if (media->param.slen) { 
    1287         pj_memcpy(p, media->param.ptr, media->param.slen); 
    1288         p += media->param.slen; 
    1289     } 
     1349    pc = pjsip_parser_const(); 
     1350    printed = pjsip_param_print_on(&media->param, p, buf+len-p, 
     1351                                   &pc->pjsip_TOKEN_SPEC, 
     1352                                   &pc->pjsip_TOKEN_SPEC, ';'); 
     1353    if (printed < 0) 
     1354        return -1; 
     1355 
     1356    p += printed; 
    12901357 
    12911358    return p-buf; 
     1359} 
     1360 
     1361 
     1362PJ_DEF(int) pjsip_media_type_print(char *buf, unsigned len, 
     1363                                   const pjsip_media_type *media) 
     1364{ 
     1365    return print_media_type(buf, len, media); 
    12921366} 
    12931367 
     
    13001374 
    13011375    if ((pj_ssize_t)size < hname->slen +  
    1302                            hdr->media.type.slen + hdr->media.subtype.slen +  
    1303                            hdr->media.param.slen + 8) 
     1376                           hdr->media.type.slen + hdr->media.subtype.slen + 8) 
    13041377    { 
    13051378        return -1; 
     
    13111384    *p++ = ' '; 
    13121385 
    1313     len = print_media_type(p, &hdr->media); 
     1386    len = print_media_type(p, buf+size-p, &hdr->media); 
    13141387    p += len; 
    13151388 
     
    13241397    pj_strdup(pool, &hdr->media.type, &rhs->media.type); 
    13251398    pj_strdup(pool, &hdr->media.subtype, &rhs->media.subtype); 
    1326     pj_strdup(pool, &hdr->media.param, &rhs->media.param); 
     1399    pjsip_param_clone(pool, &hdr->media.param, &rhs->media.param); 
    13271400    return hdr; 
    13281401} 
     
    20792152 
    20802153    /* Duplicate content-type */ 
    2081     pj_strdup(pool, &dst_body->content_type.type,  
    2082                     &src_body->content_type.type); 
    2083     pj_strdup(pool, &dst_body->content_type.subtype,  
    2084                     &src_body->content_type.subtype); 
    2085     pj_strdup(pool, &dst_body->content_type.param, 
    2086                     &src_body->content_type.param); 
     2154    pjsip_media_type_cp(pool, &dst_body->content_type, 
     2155                        &src_body->content_type); 
    20872156 
    20882157    /* Duplicate data. */ 
     
    21302199    pj_strdup(pool, &body->content_type.type, type); 
    21312200    pj_strdup(pool, &body->content_type.subtype, subtype); 
    2132     body->content_type.param.slen = 0; 
     2201    pj_list_init(&body->content_type.param); 
    21332202 
    21342203    body->data = pj_pool_alloc(pool, text->slen); 
  • pjproject/trunk/pjsip/src/test/msg_test.c

    r2724 r3241  
    482482    pjsip_via_hdr *via; 
    483483    pjsip_generic_string_hdr *generic; 
     484    pjsip_param *prm; 
    484485    pj_str_t str; 
    485486 
     
    570571    pj_strdup2(pool, &ctype->media.type, "text"); 
    571572    pj_strdup2(pool, &ctype->media.subtype, "html"); 
    572     pj_strdup2(pool, &ctype->media.param, ";charset=ISO-8859-4"); 
     573    prm = PJ_POOL_ALLOC_T(pool, pjsip_param); 
     574    prm->name = pj_str("charset"); 
     575    prm->value = pj_str("ISO-8859-4"); 
     576    pj_list_push_back(&ctype->media.param, prm); 
    573577 
    574578    /* "Route: <sip:bigbox3.site3.atlanta.com;lr>,\r\n" */ 
     
    15911595{ 
    15921596    pjsip_ctype_hdr *hdr = (pjsip_ctype_hdr*)h; 
     1597    const pjsip_param *prm; 
    15931598 
    15941599    if (h->type != PJSIP_H_CONTENT_TYPE) 
     
    16041609     * pjsip will print the parameter unescaped. 
    16051610     */ 
    1606     PJ_TODO(FIX_PARAMETER_IN_MEDIA_TYPE); 
    1607  
    1608     if (pj_strcmp2(&hdr->media.param, ";" GENERIC_PARAM_PARSED)) 
    1609         return -1940; 
     1611    prm = hdr->media.param.next; 
     1612    if (prm == &hdr->media.param) return -1940; 
     1613    if (pj_strcmp2(&prm->name, "p0")) return -1941; 
     1614    if (pj_strcmp2(&prm->value, "a")) return -1942; 
     1615 
     1616    prm = prm->next; 
     1617    if (prm == &hdr->media.param) return -1950; 
     1618    if (pj_strcmp2(&prm->name, "p1")) { PJ_LOG(3,("", "%.*s", (int)prm->name.slen, prm->name.ptr)); return -1951; } 
     1619    if (pj_strcmp2(&prm->value, "\"ab:;cd\"")) { PJ_LOG(3,("", "%.*s", (int)prm->value.slen, prm->value.ptr)); return -1952; } 
     1620 
     1621    prm = prm->next; 
     1622    if (prm == &hdr->media.param) return -1960; 
     1623    if (pj_strcmp2(&prm->name, "p2")) return -1961; 
     1624    if (pj_strcmp2(&prm->value, "ab:cd")) return -1962; 
     1625 
     1626    prm = prm->next; 
     1627    if (prm == &hdr->media.param) return -1970; 
     1628    if (pj_strcmp2(&prm->name, "p3")) return -1971; 
     1629    if (pj_strcmp2(&prm->value, "")) return -1972; 
    16101630 
    16111631    return 0; 
Note: See TracChangeset for help on using the changeset viewer.