Ignore:
Timestamp:
Jan 30, 2006 6:40:05 PM (18 years ago)
Author:
bennylp
Message:

Finished implementation of UA layer (to be tested)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • pjproject/trunk/pjsip/src/pjsip/sip_msg.c

    r119 r127  
    499499}; 
    500500 
    501 PJ_DEF(pjsip_generic_string_hdr*) pjsip_generic_string_hdr_create( pj_pool_t *pool, 
    502                                                      const pj_str_t *hnames ) 
    503 { 
    504     pjsip_generic_string_hdr *hdr = pj_pool_alloc(pool, sizeof(pjsip_generic_string_hdr)); 
     501PJ_DEF(pjsip_generic_string_hdr*)  
     502pjsip_generic_string_hdr_init( pj_pool_t *pool, 
     503                               void *mem, 
     504                               const pj_str_t *hnames, 
     505                               const pj_str_t *hvalue) 
     506{ 
     507    pjsip_generic_string_hdr *hdr = mem; 
     508 
    505509    init_hdr(hdr, PJSIP_H_OTHER, &generic_hdr_vptr); 
    506510    if (hnames) { 
    … …  
    508512        hdr->sname = hdr->name; 
    509513    } 
    510     hdr->hvalue.ptr = NULL; 
    511     hdr->hvalue.slen = 0; 
    512     return hdr; 
    513 } 
    514  
    515 PJ_DEF(pjsip_generic_string_hdr*) pjsip_generic_string_hdr_create_with_text( pj_pool_t *pool, 
    516                                                                const pj_str_t *hname, 
    517                                                                const pj_str_t *hvalue) 
    518 { 
    519     pjsip_generic_string_hdr *hdr = pjsip_generic_string_hdr_create(pool, hname); 
    520     pj_strdup(pool, &hdr->hvalue, hvalue); 
    521     return hdr; 
    522 } 
    523  
    524 static int pjsip_generic_string_hdr_print( pjsip_generic_string_hdr *hdr,  
    525                                     char *buf, pj_size_t size) 
     514    if (hvalue) { 
     515        pj_strdup(pool, &hdr->hvalue, hvalue); 
     516    } else { 
     517        hdr->hvalue.ptr = NULL; 
     518        hdr->hvalue.slen = 0; 
     519    } 
     520 
     521    return hdr; 
     522} 
     523 
     524PJ_DEF(pjsip_generic_string_hdr*)  
     525pjsip_generic_string_hdr_create( pj_pool_t *pool, 
     526                                 const pj_str_t *hnames, 
     527                                 const pj_str_t *hvalue) 
     528{ 
     529    void *mem = pj_pool_alloc(pool, sizeof(pjsip_generic_string_hdr)); 
     530    return pjsip_generic_string_hdr_init(pool, mem, hnames, hvalue); 
     531} 
     532 
     533static int pjsip_generic_string_hdr_print( pjsip_generic_string_hdr *hdr, 
     534                                           char *buf, pj_size_t size) 
    526535{ 
    527536    char *p = buf; 
    … …  
    544553                                                   const pjsip_generic_string_hdr *rhs) 
    545554{ 
    546     pjsip_generic_string_hdr *hdr = pjsip_generic_string_hdr_create(pool, &rhs->name); 
     555    pjsip_generic_string_hdr *hdr; 
     556     
     557    hdr = pjsip_generic_string_hdr_create(pool, &rhs->name, &rhs->hvalue); 
    547558 
    548559    hdr->type = rhs->type; 
    549560    hdr->sname = hdr->name; 
    550     pj_strdup( pool, &hdr->hvalue, &rhs->hvalue); 
    551561    return hdr; 
    552562} 
    … …  
    579589}; 
    580590 
    581 PJ_DEF(pjsip_generic_int_hdr*) pjsip_generic_int_hdr_create( pj_pool_t *pool, 
    582                                                      const pj_str_t *hnames ) 
    583 { 
    584     pjsip_generic_int_hdr *hdr = pj_pool_alloc(pool, sizeof(pjsip_generic_int_hdr)); 
     591PJ_DEF(pjsip_generic_int_hdr*) pjsip_generic_int_hdr_init(  pj_pool_t *pool, 
     592                                                            void *mem, 
     593                                                            const pj_str_t *hnames, 
     594                                                            int value) 
     595{ 
     596    pjsip_generic_int_hdr *hdr = mem; 
     597 
    585598    init_hdr(hdr, PJSIP_H_OTHER, &generic_int_hdr_vptr); 
    586599    if (hnames) { 
    … …  
    588601        hdr->sname = hdr->name; 
    589602    } 
    590     hdr->ivalue = 0; 
    591     return hdr; 
    592 } 
    593  
    594 PJ_DEF(pjsip_generic_int_hdr*) pjsip_generic_int_hdr_create_with_value( pj_pool_t *pool, 
    595                                                                const pj_str_t *hname, 
    596                                                                int value) 
    597 { 
    598     pjsip_generic_int_hdr *hdr = pjsip_generic_int_hdr_create(pool, hname); 
    599603    hdr->ivalue = value; 
    600604    return hdr; 
     605} 
     606 
     607PJ_DEF(pjsip_generic_int_hdr*) pjsip_generic_int_hdr_create( pj_pool_t *pool, 
     608                                                     const pj_str_t *hnames, 
     609                                                     int value) 
     610{ 
     611    void *mem = pj_pool_alloc(pool, sizeof(pjsip_generic_int_hdr)); 
     612    return pjsip_generic_int_hdr_init(pool, mem, hnames, value); 
    601613} 
    602614 
    … …  
    652664}; 
    653665 
    654 PJ_DEF(pjsip_generic_array_hdr*) pjsip_generic_array_create( pj_pool_t *pool, 
    655                                                              const pj_str_t *hnames) 
    656 { 
    657     pjsip_generic_array_hdr *hdr = pj_pool_alloc(pool, sizeof(pjsip_generic_array_hdr)); 
     666 
     667PJ_DEF(pjsip_generic_array_hdr*) pjsip_generic_array_hdr_init( pj_pool_t *pool, 
     668                                                               void *mem, 
     669                                                               const pj_str_t *hnames) 
     670{ 
     671    pjsip_generic_array_hdr *hdr = mem; 
     672 
    658673    init_hdr(hdr, PJSIP_H_OTHER, &generic_array_hdr_vptr); 
    659674    if (hnames) { 
    … …  
    663678    hdr->count = 0; 
    664679    return hdr; 
     680} 
     681 
     682PJ_DEF(pjsip_generic_array_hdr*) pjsip_generic_array_hdr_create( pj_pool_t *pool, 
     683                                                             const pj_str_t *hnames) 
     684{ 
     685    void *mem = pj_pool_alloc(pool, sizeof(pjsip_generic_array_hdr)); 
     686    return pjsip_generic_array_hdr_init(pool, mem, hnames); 
    665687 
    666688} 
    … …  
    714736 * Accept header. 
    715737 */ 
    716 PJ_DEF(pjsip_accept_hdr*) pjsip_accept_hdr_create(pj_pool_t *pool) 
    717 { 
    718     pjsip_accept_hdr *hdr = pj_pool_alloc(pool, sizeof(*hdr)); 
     738PJ_DEF(pjsip_accept_hdr*) pjsip_accept_hdr_init( pj_pool_t *pool, 
     739                                                 void *mem ) 
     740{ 
     741    pjsip_accept_hdr *hdr = mem; 
     742 
     743    PJ_UNUSED_ARG(pool); 
     744 
    719745    init_hdr(hdr, PJSIP_H_ACCEPT, &generic_array_hdr_vptr); 
    720746    hdr->count = 0; 
    … …  
    722748} 
    723749 
     750PJ_DEF(pjsip_accept_hdr*) pjsip_accept_hdr_create(pj_pool_t *pool) 
     751{ 
     752    void *mem = pj_pool_alloc(pool, sizeof(pjsip_accept_hdr)); 
     753    return pjsip_accept_hdr_init(pool, mem); 
     754} 
     755 
    724756 
    725757/////////////////////////////////////////////////////////////////////////////// 
    … …  
    728760 */ 
    729761 
    730 PJ_DEF(pjsip_allow_hdr*) pjsip_allow_hdr_create(pj_pool_t *pool) 
    731 { 
    732     pjsip_allow_hdr *hdr = pj_pool_alloc(pool, sizeof(*hdr)); 
     762PJ_DEF(pjsip_allow_hdr*) pjsip_allow_hdr_init( pj_pool_t *pool, 
     763                                               void *mem ) 
     764{ 
     765    pjsip_allow_hdr *hdr = mem; 
     766 
     767    PJ_UNUSED_ARG(pool); 
     768 
    733769    init_hdr(hdr, PJSIP_H_ALLOW, &generic_array_hdr_vptr); 
    734770    hdr->count = 0; 
    … …  
    736772} 
    737773 
     774PJ_DEF(pjsip_allow_hdr*) pjsip_allow_hdr_create(pj_pool_t *pool) 
     775{ 
     776    void *mem = pj_pool_alloc(pool, sizeof(pjsip_allow_hdr)); 
     777    return pjsip_allow_hdr_init(pool, mem); 
     778} 
     779 
    738780/////////////////////////////////////////////////////////////////////////////// 
    739781/* 
    … …  
    741783 */ 
    742784 
     785PJ_DEF(pjsip_cid_hdr*) pjsip_cid_hdr_init( pj_pool_t *pool, 
     786                                           void *mem ) 
     787{ 
     788    pjsip_cid_hdr *hdr = mem; 
     789 
     790    PJ_UNUSED_ARG(pool); 
     791 
     792    init_hdr(hdr, PJSIP_H_CALL_ID, &generic_hdr_vptr); 
     793    return hdr; 
     794 
     795} 
     796 
    743797PJ_DEF(pjsip_cid_hdr*) pjsip_cid_hdr_create( pj_pool_t *pool ) 
    744798{ 
    745     pjsip_cid_hdr *hdr = pj_pool_alloc(pool, sizeof(*hdr)); 
    746     init_hdr(hdr, PJSIP_H_CALL_ID, &generic_hdr_vptr); 
    747     return hdr; 
     799    void *mem = pj_pool_alloc(pool, sizeof(pjsip_cid_hdr)); 
     800    return pjsip_cid_hdr_init(pool, mem); 
    748801} 
    749802 
    … …  
    764817}; 
    765818 
    766 PJ_DEF(pjsip_clen_hdr*) pjsip_clen_hdr_create( pj_pool_t *pool ) 
    767 { 
    768     pjsip_clen_hdr *hdr = pj_pool_alloc(pool, sizeof(pjsip_clen_hdr)); 
     819PJ_DEF(pjsip_clen_hdr*) pjsip_clen_hdr_init( pj_pool_t *pool, 
     820                                             void *mem ) 
     821{ 
     822    pjsip_clen_hdr *hdr = mem; 
     823 
     824    PJ_UNUSED_ARG(pool); 
     825 
    769826    init_hdr(hdr, PJSIP_H_CONTENT_LENGTH, &clen_hdr_vptr); 
    770827    hdr->len = 0; 
    771828    return hdr; 
     829} 
     830 
     831PJ_DEF(pjsip_clen_hdr*) pjsip_clen_hdr_create( pj_pool_t *pool ) 
     832{ 
     833    void *mem = pj_pool_alloc(pool, sizeof(pjsip_clen_hdr)); 
     834    return pjsip_clen_hdr_init(pool, mem); 
    772835} 
    773836 
    … …  
    816879}; 
    817880 
    818 PJ_DEF(pjsip_cseq_hdr*) pjsip_cseq_hdr_create( pj_pool_t *pool ) 
    819 { 
    820     pjsip_cseq_hdr *hdr = pj_pool_alloc(pool, sizeof(pjsip_cseq_hdr)); 
     881PJ_DEF(pjsip_cseq_hdr*) pjsip_cseq_hdr_init( pj_pool_t *pool, 
     882                                             void *mem ) 
     883{ 
     884    pjsip_cseq_hdr *hdr = mem; 
     885 
     886    PJ_UNUSED_ARG(pool); 
     887 
    821888    init_hdr(hdr, PJSIP_H_CSEQ, &cseq_hdr_vptr); 
    822889    hdr->cseq = 0; 
    … …  
    827894} 
    828895 
     896PJ_DEF(pjsip_cseq_hdr*) pjsip_cseq_hdr_create( pj_pool_t *pool ) 
     897{ 
     898    void *mem = pj_pool_alloc(pool, sizeof(pjsip_cseq_hdr)); 
     899    return pjsip_cseq_hdr_init(pool, mem); 
     900} 
     901 
    829902static int pjsip_cseq_hdr_print( pjsip_cseq_hdr *hdr, char *buf, pj_size_t size) 
    830903{ 
    … …  
    885958}; 
    886959 
    887 PJ_DEF(pjsip_contact_hdr*) pjsip_contact_hdr_create( pj_pool_t *pool ) 
    888 { 
    889     pjsip_contact_hdr *hdr = pj_pool_calloc(pool, 1, sizeof(*hdr)); 
     960PJ_DEF(pjsip_contact_hdr*) pjsip_contact_hdr_init( pj_pool_t *pool, 
     961                                                   void *mem ) 
     962{ 
     963    pjsip_contact_hdr *hdr = mem; 
     964 
     965    PJ_UNUSED_ARG(pool); 
     966 
     967    pj_memset(mem, 0, sizeof(pjsip_contact_hdr)); 
    890968    init_hdr(hdr, PJSIP_H_CONTACT, &contact_hdr_vptr); 
    891969    hdr->expires = -1; 
    892970    pj_list_init(&hdr->other_param); 
    893971    return hdr; 
     972} 
     973 
     974PJ_DEF(pjsip_contact_hdr*) pjsip_contact_hdr_create( pj_pool_t *pool ) 
     975{ 
     976    void *mem = pj_pool_alloc(pool, sizeof(pjsip_contact_hdr)); 
     977    return pjsip_contact_hdr_init(pool, mem); 
    894978} 
    895979 
    … …  
    10031087}; 
    10041088 
     1089PJ_DEF(pjsip_ctype_hdr*) pjsip_ctype_hdr_init( pj_pool_t *pool, 
     1090                                               void *mem ) 
     1091{ 
     1092    pjsip_ctype_hdr *hdr = mem; 
     1093 
     1094    PJ_UNUSED_ARG(pool); 
     1095 
     1096    pj_memset(mem, 0, sizeof(pjsip_ctype_hdr)); 
     1097    init_hdr(hdr, PJSIP_H_CONTENT_TYPE, &ctype_hdr_vptr); 
     1098    return hdr; 
     1099 
     1100} 
     1101 
    10051102PJ_DEF(pjsip_ctype_hdr*) pjsip_ctype_hdr_create( pj_pool_t *pool ) 
    10061103{ 
    1007     pjsip_ctype_hdr *hdr = pj_pool_calloc(pool, 1, sizeof(*hdr)); 
    1008     init_hdr(hdr, PJSIP_H_CONTENT_TYPE, &ctype_hdr_vptr); 
    1009     return hdr; 
     1104    void *mem = pj_pool_alloc(pool, sizeof(pjsip_ctype_hdr)); 
     1105    return pjsip_ctype_hdr_init(pool, mem); 
    10101106} 
    10111107 
    … …  
    10671163 * Expires header. 
    10681164 */ 
    1069 PJ_DEF(pjsip_expires_hdr*) pjsip_expires_hdr_create( pj_pool_t *pool ) 
    1070 { 
    1071     pjsip_expires_hdr *hdr = pj_pool_alloc(pool, sizeof(*hdr)); 
     1165PJ_DEF(pjsip_expires_hdr*) pjsip_expires_hdr_init( pj_pool_t *pool, 
     1166                                                   void *mem, 
     1167                                                   int value) 
     1168{ 
     1169    pjsip_expires_hdr *hdr = mem; 
     1170 
     1171    PJ_UNUSED_ARG(pool); 
     1172 
    10721173    init_hdr(hdr, PJSIP_H_EXPIRES, &generic_int_hdr_vptr); 
    1073     hdr->ivalue = 0; 
    1074     return hdr; 
     1174    hdr->ivalue = value; 
     1175    return hdr; 
     1176 
     1177} 
     1178 
     1179PJ_DEF(pjsip_expires_hdr*) pjsip_expires_hdr_create( pj_pool_t *pool, 
     1180                                                     int value ) 
     1181{ 
     1182    void *mem = pj_pool_alloc(pool, sizeof(pjsip_expires_hdr)); 
     1183    return pjsip_expires_hdr_init(pool, mem, value); 
    10751184} 
    10761185 
    … …  
    10941203}; 
    10951204 
    1096 PJ_DEF(pjsip_from_hdr*) pjsip_from_hdr_create( pj_pool_t *pool ) 
    1097 { 
    1098     pjsip_from_hdr *hdr = pj_pool_calloc(pool, 1, sizeof(*hdr)); 
     1205PJ_DEF(pjsip_from_hdr*) pjsip_from_hdr_init( pj_pool_t *pool, 
     1206                                             void *mem ) 
     1207{ 
     1208    pjsip_from_hdr *hdr = mem; 
     1209 
     1210    PJ_UNUSED_ARG(pool); 
     1211 
     1212    pj_memset(mem, 0, sizeof(pjsip_from_hdr)); 
    10991213    init_hdr(hdr, PJSIP_H_FROM, &fromto_hdr_vptr); 
    11001214    pj_list_init(&hdr->other_param); 
    … …  
    11021216} 
    11031217 
    1104 PJ_DEF(pjsip_to_hdr*) pjsip_to_hdr_create( pj_pool_t *pool ) 
    1105 { 
    1106     pjsip_to_hdr *hdr = pj_pool_calloc(pool, 1, sizeof(*hdr)); 
     1218PJ_DEF(pjsip_from_hdr*) pjsip_from_hdr_create( pj_pool_t *pool ) 
     1219{ 
     1220    void *mem = pj_pool_alloc(pool, sizeof(pjsip_from_hdr)); 
     1221    return pjsip_from_hdr_init(pool, mem); 
     1222} 
     1223 
     1224PJ_DEF(pjsip_to_hdr*) pjsip_to_hdr_init( pj_pool_t *pool, 
     1225                                         void *mem ) 
     1226{ 
     1227    pjsip_to_hdr *hdr = mem; 
     1228 
     1229    PJ_UNUSED_ARG(pool); 
     1230 
     1231    pj_memset(mem, 0, sizeof(pjsip_to_hdr)); 
    11071232    init_hdr(hdr, PJSIP_H_TO, &fromto_hdr_vptr); 
    11081233    pj_list_init(&hdr->other_param); 
    11091234    return hdr; 
    1110 } 
    1111  
    1112 PJ_DEF(pjsip_from_hdr*) pjsip_fromto_set_from( pjsip_fromto_hdr *hdr ) 
     1235 
     1236} 
     1237 
     1238PJ_DEF(pjsip_to_hdr*) pjsip_to_hdr_create( pj_pool_t *pool ) 
     1239{ 
     1240    void *mem = pj_pool_alloc(pool, sizeof(pjsip_to_hdr)); 
     1241    return pjsip_to_hdr_init(pool, mem); 
     1242} 
     1243 
     1244PJ_DEF(pjsip_from_hdr*) pjsip_fromto_hdr_set_from( pjsip_fromto_hdr *hdr ) 
    11131245{ 
    11141246    hdr->type = PJSIP_H_FROM; 
    … …  
    11171249} 
    11181250 
    1119 PJ_DEF(pjsip_to_hdr*) pjsip_fromto_set_to( pjsip_fromto_hdr *hdr ) 
     1251PJ_DEF(pjsip_to_hdr*) pjsip_fromto_hdr_set_to( pjsip_fromto_hdr *hdr ) 
    11201252{ 
    11211253    hdr->type = PJSIP_H_TO; 
    … …  
    11841316 * Max-Forwards header. 
    11851317 */ 
    1186 PJ_DEF(pjsip_max_forwards_hdr*) pjsip_max_forwards_hdr_create(pj_pool_t *pool) 
    1187 { 
    1188     pjsip_max_forwards_hdr *hdr = pj_pool_alloc(pool, sizeof(*hdr)); 
     1318PJ_DEF(pjsip_max_fwd_hdr*) pjsip_max_fwd_hdr_init( pj_pool_t *pool, 
     1319                                                   void *mem, 
     1320                                                   int value) 
     1321{ 
     1322    pjsip_max_fwd_hdr *hdr = mem; 
     1323 
     1324    PJ_UNUSED_ARG(pool); 
     1325 
    11891326    init_hdr(hdr, PJSIP_H_MAX_FORWARDS, &generic_int_hdr_vptr); 
    1190     hdr->ivalue = 0; 
    1191     return hdr; 
     1327    hdr->ivalue = value; 
     1328    return hdr; 
     1329 
     1330} 
     1331 
     1332PJ_DEF(pjsip_max_fwd_hdr*) pjsip_max_fwd_hdr_create(pj_pool_t *pool, 
     1333                                                    int value) 
     1334{ 
     1335    void *mem = pj_pool_alloc(pool, sizeof(pjsip_max_fwd_hdr)); 
     1336    return pjsip_max_fwd_hdr_init(pool, mem, value); 
    11921337} 
    11931338 
    … …  
    11971342 * Min-Expires header. 
    11981343 */ 
    1199 PJ_DECL(pjsip_min_expires_hdr*) pjsip_min_expires_hdr_create(pj_pool_t *pool) 
    1200 { 
    1201     pjsip_min_expires_hdr *hdr = pj_pool_alloc(pool, sizeof(*hdr)); 
     1344PJ_DEF(pjsip_min_expires_hdr*) pjsip_min_expires_hdr_init( pj_pool_t *pool, 
     1345                                                           void *mem, 
     1346                                                           int value ) 
     1347{ 
     1348    pjsip_min_expires_hdr *hdr = mem; 
     1349 
     1350    PJ_UNUSED_ARG(pool); 
     1351 
    12021352    init_hdr(hdr, PJSIP_H_MIN_EXPIRES, &generic_int_hdr_vptr); 
    1203     hdr->ivalue = 0; 
    1204     return hdr; 
     1353    hdr->ivalue = value; 
     1354    return hdr; 
     1355} 
     1356 
     1357PJ_DEF(pjsip_min_expires_hdr*) pjsip_min_expires_hdr_create(pj_pool_t *pool, 
     1358                                                            int value ) 
     1359{ 
     1360    void *mem = pj_pool_alloc(pool, sizeof(pjsip_min_expires_hdr)); 
     1361    return pjsip_min_expires_hdr_init(pool, mem, value ); 
    12051362} 
    12061363 
    … …  
    12201377}; 
    12211378 
    1222 PJ_DEF(pjsip_rr_hdr*) pjsip_rr_hdr_create( pj_pool_t *pool ) 
    1223 { 
    1224     pjsip_rr_hdr *hdr = pj_pool_alloc(pool, sizeof(*hdr)); 
     1379PJ_DEF(pjsip_rr_hdr*) pjsip_rr_hdr_init( pj_pool_t *pool, 
     1380                                         void *mem ) 
     1381{ 
     1382    pjsip_rr_hdr *hdr = mem; 
     1383 
     1384    PJ_UNUSED_ARG(pool); 
     1385 
    12251386    init_hdr(hdr, PJSIP_H_RECORD_ROUTE, &routing_hdr_vptr); 
    12261387    pjsip_name_addr_init(&hdr->name_addr); 
    12271388    pj_list_init(&hdr->other_param); 
    12281389    return hdr; 
    1229 } 
    1230  
    1231 PJ_DEF(pjsip_route_hdr*) pjsip_route_hdr_create( pj_pool_t *pool ) 
    1232 { 
    1233     pjsip_route_hdr *hdr = pj_pool_alloc(pool, sizeof(*hdr)); 
     1390 
     1391} 
     1392 
     1393PJ_DEF(pjsip_rr_hdr*) pjsip_rr_hdr_create( pj_pool_t *pool ) 
     1394{ 
     1395    void *mem = pj_pool_alloc(pool, sizeof(pjsip_rr_hdr)); 
     1396    return pjsip_rr_hdr_init(pool, mem); 
     1397} 
     1398 
     1399PJ_DEF(pjsip_route_hdr*) pjsip_route_hdr_init( pj_pool_t *pool, 
     1400                                               void *mem ) 
     1401{ 
     1402    pjsip_route_hdr *hdr = mem; 
     1403 
     1404    PJ_UNUSED_ARG(pool); 
     1405 
    12341406    init_hdr(hdr, PJSIP_H_ROUTE, &routing_hdr_vptr); 
    12351407    pjsip_name_addr_init(&hdr->name_addr); 
    12361408    pj_list_init(&hdr->other_param); 
    12371409    return hdr; 
     1410} 
     1411 
     1412PJ_DEF(pjsip_route_hdr*) pjsip_route_hdr_create( pj_pool_t *pool ) 
     1413{ 
     1414    void *mem = pj_pool_alloc(pool, sizeof(pjsip_route_hdr)); 
     1415    return pjsip_route_hdr_init(pool, mem); 
    12381416} 
    12391417 
    … …  
    13051483 * Require header. 
    13061484 */ 
    1307 PJ_DEF(pjsip_require_hdr*) pjsip_require_hdr_create(pj_pool_t *pool) 
    1308 { 
    1309     pjsip_require_hdr *hdr = pj_pool_alloc(pool, sizeof(*hdr)); 
     1485PJ_DEF(pjsip_require_hdr*) pjsip_require_hdr_init( pj_pool_t *pool, 
     1486                                                   void *mem ) 
     1487{ 
     1488    pjsip_require_hdr *hdr = mem; 
     1489 
     1490    PJ_UNUSED_ARG(pool); 
     1491 
    13101492    init_hdr(hdr, PJSIP_H_REQUIRE, &generic_array_hdr_vptr); 
    13111493    hdr->count = 0; 
    … …  
    13131495} 
    13141496 
     1497PJ_DEF(pjsip_require_hdr*) pjsip_require_hdr_create(pj_pool_t *pool) 
     1498{ 
     1499    void *mem = pj_pool_alloc(pool, sizeof(pjsip_require_hdr)); 
     1500    return pjsip_require_hdr_init(pool, mem); 
     1501} 
     1502 
    13151503/////////////////////////////////////////////////////////////////////////////// 
    13161504/* 
    13171505 * Retry-After header. 
    13181506 */ 
    1319 PJ_DEF(pjsip_retry_after_hdr*) pjsip_retry_after_hdr_create(pj_pool_t *pool) 
    1320 { 
    1321     pjsip_retry_after_hdr *hdr = pj_pool_alloc(pool, sizeof(*hdr)); 
     1507PJ_DEF(pjsip_retry_after_hdr*) pjsip_retry_after_hdr_init( pj_pool_t *pool, 
     1508                                                           void *mem, 
     1509                                                           int value ) 
     1510{ 
     1511    pjsip_retry_after_hdr *hdr = mem; 
     1512 
     1513    PJ_UNUSED_ARG(pool); 
     1514 
    13221515    init_hdr(hdr, PJSIP_H_RETRY_AFTER, &generic_int_hdr_vptr); 
    1323     hdr->ivalue = 0; 
    1324     return hdr; 
     1516    hdr->ivalue = value; 
     1517    return hdr; 
     1518} 
     1519 
     1520PJ_DEF(pjsip_retry_after_hdr*) pjsip_retry_after_hdr_create(pj_pool_t *pool, 
     1521                                                            int value ) 
     1522{ 
     1523    void *mem = pj_pool_alloc(pool, sizeof(pjsip_retry_after_hdr)); 
     1524    return pjsip_retry_after_hdr_init(pool, mem, value ); 
    13251525} 
    13261526 
    … …  
    13301530 * Supported header. 
    13311531 */ 
    1332 PJ_DEF(pjsip_supported_hdr*) pjsip_supported_hdr_create(pj_pool_t *pool) 
    1333 { 
    1334     pjsip_supported_hdr *hdr = pj_pool_alloc(pool, sizeof(*hdr)); 
     1532PJ_DEF(pjsip_supported_hdr*) pjsip_supported_hdr_init( pj_pool_t *pool, 
     1533                                                       void *mem ) 
     1534{ 
     1535    pjsip_supported_hdr *hdr = mem; 
     1536 
     1537    PJ_UNUSED_ARG(pool); 
    13351538    init_hdr(hdr, PJSIP_H_SUPPORTED, &generic_array_hdr_vptr); 
    13361539    hdr->count = 0; 
    … …  
    13381541} 
    13391542 
     1543PJ_DEF(pjsip_supported_hdr*) pjsip_supported_hdr_create(pj_pool_t *pool) 
     1544{ 
     1545    void *mem = pj_pool_alloc(pool, sizeof(pjsip_supported_hdr)); 
     1546    return pjsip_supported_hdr_init(pool, mem); 
     1547} 
     1548 
    13401549 
    13411550/////////////////////////////////////////////////////////////////////////////// 
    … …  
    13431552 * Unsupported header. 
    13441553 */ 
    1345 PJ_DEF(pjsip_unsupported_hdr*) pjsip_unsupported_hdr_create(pj_pool_t *pool) 
    1346 { 
    1347     pjsip_unsupported_hdr *hdr = pj_pool_alloc(pool, sizeof(*hdr)); 
     1554PJ_DEF(pjsip_unsupported_hdr*) pjsip_unsupported_hdr_init( pj_pool_t *pool, 
     1555                                                           void *mem ) 
     1556{ 
     1557    pjsip_unsupported_hdr *hdr = mem; 
     1558     
     1559    PJ_UNUSED_ARG(pool); 
     1560 
    13481561    init_hdr(hdr, PJSIP_H_UNSUPPORTED, &generic_array_hdr_vptr); 
    13491562    hdr->count = 0; 
    13501563    return hdr; 
     1564} 
     1565 
     1566PJ_DEF(pjsip_unsupported_hdr*) pjsip_unsupported_hdr_create(pj_pool_t *pool) 
     1567{ 
     1568    void *mem = pj_pool_alloc(pool, sizeof(pjsip_unsupported_hdr)); 
     1569    return pjsip_unsupported_hdr_init(pool, mem); 
    13511570} 
    13521571 
    … …  
    13661585}; 
    13671586 
    1368 PJ_DEF(pjsip_via_hdr*) pjsip_via_hdr_create( pj_pool_t *pool ) 
    1369 { 
    1370     pjsip_via_hdr *hdr = pj_pool_calloc(pool, 1, sizeof(*hdr)); 
     1587PJ_DEF(pjsip_via_hdr*) pjsip_via_hdr_init( pj_pool_t *pool, 
     1588                                           void *mem ) 
     1589{ 
     1590    pjsip_via_hdr *hdr = mem; 
     1591 
     1592    PJ_UNUSED_ARG(pool); 
     1593 
     1594    pj_memset(mem, 0, sizeof(pjsip_via_hdr)); 
    13711595    init_hdr(hdr, PJSIP_H_VIA, &via_hdr_vptr); 
    1372     //hdr->sent_by.port = 5060; 
    13731596    hdr->ttl_param = -1; 
    13741597    hdr->rport_param = -1; 
    13751598    pj_list_init(&hdr->other_param); 
    13761599    return hdr; 
     1600 
     1601} 
     1602 
     1603PJ_DEF(pjsip_via_hdr*) pjsip_via_hdr_create( pj_pool_t *pool ) 
     1604{ 
     1605    void *mem = pj_pool_alloc(pool, sizeof(pjsip_via_hdr)); 
     1606    return pjsip_via_hdr_init(pool, mem); 
    13771607} 
    13781608 
Note: See TracChangeset for help on using the changeset viewer.