Changeset 1241


Ignore:
Timestamp:
May 2, 2007 5:14:29 AM (12 years ago)
Author:
bennylp
Message:

Ported PJSIP and PJSIP-SIMPLE to Symbian

Location:
pjproject/trunk
Files:
20 edited

Legend:

Unmodified
Added
Removed
  • pjproject/trunk/build.symbian/pjsip_simple.mmp

    r1240 r1241  
    1010MACRO           PJ_IMPORTING 
    1111 
    12 //OPTION                CW -lang c++ 
     12OPTION          CW -lang c++ 
    1313 
    1414 
  • pjproject/trunk/pjsip/src/pjsip-simple/evsub.c

    r974 r1241  
    5252const pjsip_method pjsip_subscribe_method =  
    5353{ 
    54     PJSIP_SUBSCRIBE_METHOD, 
     54    (pjsip_method_e) PJSIP_SUBSCRIBE_METHOD, 
    5555    { "SUBSCRIBE", 9 } 
    5656}; 
     
    5858const pjsip_method pjsip_notify_method =  
    5959{ 
    60     PJSIP_NOTIFY_METHOD, 
     60    (pjsip_method_e) PJSIP_NOTIFY_METHOD, 
    6161    { "NOTIFY", 6 } 
    6262}; 
     
    328328PJ_DEF(pjsip_evsub*) pjsip_tsx_get_evsub(pjsip_transaction *tsx) 
    329329{ 
    330     return tsx->mod_data[mod_evsub.mod.id]; 
     330    return (pjsip_evsub*) tsx->mod_data[mod_evsub.mod.id]; 
    331331} 
    332332 
     
    396396    /* Create new event package: */ 
    397397 
    398     pkg = pj_pool_alloc(mod_evsub.pool, sizeof(struct evpkg)); 
     398    pkg = PJ_POOL_ALLOC_T(mod_evsub.pool, struct evpkg); 
    399399    pkg->pkg_mod = pkg_mod; 
    400400    pkg->pkg_expires = expires; 
     
    509509    set_timer(sub, TIMER_TYPE_NONE, 0); 
    510510 
    511     /* Remote this session from dialog's list of subscription */ 
    512     dlgsub_head = sub->dlg->mod_data[mod_evsub.mod.id]; 
     511    /* Remove this session from dialog's list of subscription */ 
     512    dlgsub_head = (struct dlgsub *) sub->dlg->mod_data[mod_evsub.mod.id]; 
    513513    dlgsub = dlgsub_head->next; 
    514514    while (dlgsub != dlgsub_head) { 
     
    573573    PJ_UNUSED_ARG(timer_heap); 
    574574 
    575     sub = entry->user_data; 
     575    sub = (pjsip_evsub*) entry->user_data; 
    576576 
    577577    pjsip_dlg_inc_lock(sub->dlg); 
     
    674674    /* Init attributes: */ 
    675675 
    676     sub = pj_pool_zalloc(dlg->pool, sizeof(struct pjsip_evsub)); 
     676    sub = PJ_POOL_ZALLOC_T(dlg->pool, struct pjsip_evsub); 
    677677    sub->pool = dlg->pool; 
    678678    sub->endpt = dlg->endpt; 
     
    685685    sub->state_str = evsub_state_names[sub->state]; 
    686686    sub->expires = pjsip_expires_hdr_create(sub->pool, pkg->pkg_expires); 
    687     sub->accept = pjsip_hdr_clone(sub->pool, pkg->pkg_accept); 
     687    sub->accept = (pjsip_accept_hdr*)  
     688                  pjsip_hdr_clone(sub->pool, pkg->pkg_accept); 
    688689 
    689690    sub->timer.user_data = sub; 
     
    707708    /* Create subcription list: */ 
    708709 
    709     dlgsub_head = pj_pool_alloc(sub->pool, sizeof(struct dlgsub)); 
    710     dlgsub = pj_pool_alloc(sub->pool, sizeof(struct dlgsub)); 
     710    dlgsub_head = PJ_POOL_ALLOC_T(sub->pool, struct dlgsub); 
     711    dlgsub = PJ_POOL_ALLOC_T(sub->pool, struct dlgsub); 
    711712    dlgsub->sub = sub; 
    712713 
     
    829830 
    830831    /* Just duplicate Event header from the request */ 
    831     sub->event = pjsip_hdr_clone(sub->pool, event_hdr); 
     832    sub->event = (pjsip_event_hdr*) pjsip_hdr_clone(sub->pool, event_hdr); 
    832833 
    833834    /* Set the method: */ 
     
    851852        pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_ACCEPT, NULL); 
    852853    if (accept_hdr) 
    853         sub->accept = pjsip_hdr_clone(sub->pool, accept_hdr); 
     854        sub->accept = (pjsip_accept_hdr*)pjsip_hdr_clone(sub->pool,accept_hdr); 
    854855 
    855856    /* We can start the session: */ 
     
    942943 
    943944    /* Add Event header: */ 
    944     pjsip_msg_add_hdr( tdata->msg, 
     945    pjsip_msg_add_hdr( tdata->msg, (pjsip_hdr*) 
    945946                       pjsip_hdr_shallow_clone(tdata->pool, sub->event)); 
    946947 
     
    948949    if (expires >= 0) 
    949950        sub->expires->ivalue = expires; 
    950     pjsip_msg_add_hdr( tdata->msg, 
     951    pjsip_msg_add_hdr( tdata->msg, (pjsip_hdr*) 
    951952                       pjsip_hdr_shallow_clone(tdata->pool, sub->expires)); 
    952953 
    953954    /* Add Accept header: */ 
    954     pjsip_msg_add_hdr( tdata->msg, 
     955    pjsip_msg_add_hdr( tdata->msg, (pjsip_hdr*) 
    955956                       pjsip_hdr_shallow_clone(tdata->pool, sub->accept)); 
    956957     
    957958 
    958959    /* Add Allow-Events header: */ 
    959     pjsip_msg_add_hdr( tdata->msg, 
     960    pjsip_msg_add_hdr( tdata->msg, (pjsip_hdr*) 
    960961                       pjsip_hdr_shallow_clone(tdata->pool,  
    961962                                               mod_evsub.allow_events_hdr)); 
     
    10121013 
    10131014    /* Add expires header: */ 
    1014     pjsip_msg_add_hdr( tdata->msg, 
     1015    pjsip_msg_add_hdr( tdata->msg, (pjsip_hdr*) 
    10151016                       pjsip_hdr_shallow_clone(tdata->pool, sub->expires)); 
    10161017 
     
    10191020        const pjsip_hdr *hdr = hdr_list->next; 
    10201021        while (hdr != hdr_list) { 
    1021             pjsip_msg_add_hdr( tdata->msg, 
     1022            pjsip_msg_add_hdr( tdata->msg, (pjsip_hdr*) 
    10221023                               pjsip_hdr_clone(tdata->pool, hdr)); 
    10231024            hdr = hdr->next; 
     
    11181119 
    11191120    /* Add Event header */ 
    1120     pjsip_msg_add_hdr(tdata->msg, 
     1121    pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*) 
    11211122                      pjsip_hdr_shallow_clone(tdata->pool, sub->event)); 
    11221123 
     
    11271128 
    11281129    /* Add Allow-Events header */ 
    1129     pjsip_msg_add_hdr(tdata->msg, 
     1130    pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*) 
    11301131                      pjsip_hdr_shallow_clone(tdata->pool, mod_evsub.allow_events_hdr)); 
    11311132 
     
    12591260    } 
    12601261 
    1261     event_hdr = pjsip_msg_find_hdr_by_name(msg, &STR_EVENT, NULL); 
     1262    event_hdr = (pjsip_event_hdr*) 
     1263                pjsip_msg_find_hdr_by_name(msg, &STR_EVENT, NULL); 
    12621264    if (!event_hdr) { 
    12631265        /* Not subscription related message */ 
     
    12691271     */ 
    12701272 
    1271     dlgsub_head = dlg->mod_data[mod_evsub.mod.id]; 
     1273    dlgsub_head = (struct dlgsub*) dlg->mod_data[mod_evsub.mod.id]; 
    12721274    if (dlgsub_head == NULL) { 
    1273         dlgsub_head = pj_pool_alloc(dlg->pool, sizeof(struct dlgsub)); 
     1275        dlgsub_head = PJ_POOL_ALLOC_T(dlg->pool, struct dlgsub); 
    12741276        pj_list_init(dlgsub_head); 
    12751277        dlg->mod_data[mod_evsub.mod.id] = dlgsub_head; 
     
    14171419    hdr = res_hdr->next; 
    14181420    while (hdr != res_hdr) { 
    1419         pjsip_msg_add_hdr( tdata->msg,  
     1421        pjsip_msg_add_hdr( tdata->msg, (pjsip_hdr*) 
    14201422                           pjsip_hdr_clone(tdata->pool, hdr)); 
    14211423        hdr = hdr->next; 
     
    15501552 
    15511553                msg = event->body.tsx_state.src.rdata->msg_info.msg; 
    1552                 expires = pjsip_msg_find_hdr(msg, PJSIP_H_EXPIRES, NULL); 
     1554                expires = (pjsip_expires_hdr*) 
     1555                          pjsip_msg_find_hdr(msg, PJSIP_H_EXPIRES, NULL); 
    15531556                if (expires) { 
    15541557                    sub->expires->ivalue = expires->ivalue; 
     
    16561659 
    16571660        /* Get subscription state header. */ 
    1658         sub_state = pjsip_msg_find_hdr_by_name(msg, &STR_SUB_STATE, NULL); 
     1661        sub_state = (pjsip_sub_state_hdr*) 
     1662                    pjsip_msg_find_hdr_by_name(msg, &STR_SUB_STATE, NULL); 
    16591663        if (sub_state == NULL) { 
    16601664 
     
    18041808         * or package default expiration time. 
    18051809         */ 
    1806         event_hdr = pjsip_msg_find_hdr_by_name(msg, &STR_EVENT, NULL); 
    1807         expires = pjsip_msg_find_hdr(msg, PJSIP_H_EXPIRES, NULL); 
     1810        event_hdr = (pjsip_event_hdr*) 
     1811                    pjsip_msg_find_hdr_by_name(msg, &STR_EVENT, NULL); 
     1812        expires = (pjsip_expires_hdr*) 
     1813                  pjsip_msg_find_hdr(msg, PJSIP_H_EXPIRES, NULL); 
    18081814        if (event_hdr && expires) { 
    18091815            struct evpkg *evpkg; 
     
    18601866        if (status == PJ_SUCCESS) { 
    18611867            /* Add expires header: */ 
    1862             pjsip_msg_add_hdr( tdata->msg, 
     1868            pjsip_msg_add_hdr( tdata->msg, (pjsip_hdr*) 
    18631869                               pjsip_hdr_shallow_clone(tdata->pool,  
    18641870                                                       sub->expires)); 
  • pjproject/trunk/pjsip/src/pjsip-simple/evsub_msg.c

    r974 r1241  
    4444PJ_DEF(pjsip_event_hdr*) pjsip_event_hdr_create(pj_pool_t *pool) 
    4545{ 
    46     pjsip_event_hdr *hdr = pj_pool_zalloc(pool, sizeof(*hdr)); 
     46    pjsip_event_hdr *hdr = PJ_POOL_ZALLOC_T(pool, pjsip_event_hdr); 
    4747    hdr->type = PJSIP_H_OTHER; 
    4848    hdr->name.ptr = "Event"; 
     
    9494                               const pjsip_event_hdr *rhs ) 
    9595{ 
    96     pjsip_event_hdr *hdr = pj_pool_alloc(pool, sizeof(*hdr)); 
     96    pjsip_event_hdr *hdr = PJ_POOL_ALLOC_T(pool, pjsip_event_hdr); 
    9797    pj_memcpy(hdr, rhs, sizeof(*hdr)); 
    9898    pjsip_param_shallow_clone(pool, &hdr->other_param, &rhs->other_param); 
     
    143143{ 
    144144    pj_str_t sub_state = { "Subscription-State", 18 }; 
    145     pjsip_sub_state_hdr *hdr = pj_pool_zalloc(pool, sizeof(*hdr)); 
     145    pjsip_sub_state_hdr *hdr = PJ_POOL_ZALLOC_T(pool, pjsip_sub_state_hdr); 
    146146    hdr->type = PJSIP_H_OTHER; 
    147147    hdr->name = hdr->sname = sub_state; 
     
    209209                                  const pjsip_sub_state_hdr *rhs) 
    210210{ 
    211     pjsip_sub_state_hdr *hdr = pj_pool_alloc(pool, sizeof(*hdr)); 
     211    pjsip_sub_state_hdr *hdr = PJ_POOL_ALLOC_T(pool, pjsip_sub_state_hdr); 
    212212    pj_memcpy(hdr, rhs, sizeof(*hdr)); 
    213213    pjsip_param_shallow_clone(pool, &hdr->other_param, &rhs->other_param); 
     
    235235            hdr->id_param = pvalue; 
    236236        } else { 
    237             pjsip_param *param = pj_pool_alloc(ctx->pool, sizeof(pjsip_param)); 
     237            pjsip_param *param = PJ_POOL_ALLOC_T(ctx->pool, pjsip_param); 
    238238            param->name = pname; 
    239239            param->value = pvalue; 
     
    272272 
    273273        } else { 
    274             pjsip_param *param = pj_pool_alloc(ctx->pool, sizeof(pjsip_param)); 
     274            pjsip_param *param = PJ_POOL_ALLOC_T(ctx->pool, pjsip_param); 
    275275            param->name = pname; 
    276276            param->value = pvalue; 
  • pjproject/trunk/pjsip/src/pjsip-simple/iscomposing.c

    r974 r1241  
    9696    if (is_composing && refresh > 1 && refresh < 3601) { 
    9797        node = pj_xml_node_new(pool, &STR_REFRESH); 
    98         node->content.ptr = pj_pool_alloc(pool, 10); 
     98        node->content.ptr = (char*) pj_pool_alloc(pool, 10); 
    9999        node->content.slen = pj_utoa(refresh, node->content.ptr); 
    100100        pj_xml_add_node(doc, node); 
     
    114114                           char *buf, pj_size_t size) 
    115115{ 
    116     return pj_xml_print(msg_body->data, buf, size, PJ_TRUE); 
     116    return pj_xml_print((const pj_xml_node*)msg_body->data, buf, size,  
     117                        PJ_TRUE); 
    117118} 
    118119 
     
    124125{ 
    125126    PJ_UNUSED_ARG(len); 
    126     return pj_xml_clone( pool, data); 
     127    return pj_xml_clone( pool, (const pj_xml_node*)data); 
    127128} 
    128129 
     
    144145 
    145146 
    146     body = pj_pool_zalloc(pool, sizeof(pjsip_msg_body)); 
     147    body = PJ_POOL_ZALLOC_T(pool, pjsip_msg_body); 
    147148    body->content_type.type = STR_MIME_TYPE; 
    148149    body->content_type.subtype = STR_MIME_SUBTYPE; 
  • pjproject/trunk/pjsip/src/pjsip-simple/pidf.c

    r1146 r1241  
    8989                                    const pj_str_t *value) 
    9090{ 
    91     pj_xml_attr *attr = pj_pool_alloc(pool, sizeof(*attr)); 
     91    pj_xml_attr *attr = PJ_POOL_ALLOC_T(pool, pj_xml_attr); 
    9292    attr->name = *name; 
    9393    pj_strdup(pool, &attr->value, value); 
     
    111111                                            const pj_str_t *id) 
    112112{ 
    113     pjpidf_tuple *t = pj_pool_alloc(pool, sizeof(*t)); 
     113    pjpidf_tuple *t = PJ_POOL_ALLOC_T(pool, pjpidf_tuple); 
    114114    pjpidf_tuple_construct(pool, t, id); 
    115115    pj_xml_add_node(pres, t); 
     
    130130static pj_bool_t find_tuple_by_id(pj_xml_node *node, const void *id) 
    131131{ 
    132     return pj_xml_find_attr(node, &ID, id) != NULL; 
     132    return pj_xml_find_attr(node, &ID, (const pj_str_t*)id) != NULL; 
    133133} 
    134134 
     
    147147                                          const pj_str_t *text) 
    148148{ 
    149     pjpidf_note *note = pj_pool_alloc(pool, sizeof(*note)); 
     149    pjpidf_note *note = PJ_POOL_ALLOC_T(pool, pjpidf_note); 
    150150    xml_init_node(pool, note, &NOTE, text); 
    151151    pj_xml_add_node(pres, note); 
     
    174174    attr = xml_create_attr(pool, &ID, id); 
    175175    pj_xml_add_attr(t, attr); 
    176     st = pj_pool_alloc(pool, sizeof(*st)); 
     176    st = PJ_POOL_ALLOC_T(pool, pjpidf_status); 
    177177    pjpidf_status_construct(pool, st); 
    178178    pj_xml_add_node(t, st); 
     
    215215    pj_xml_node *node = pj_xml_find_node(t, &CONTACT); 
    216216    if (!node) { 
    217         node = pj_pool_alloc(pool, sizeof(*node)); 
     217        node = PJ_POOL_ALLOC_T(pool, pj_xml_node); 
    218218        xml_init_node(pool, node, &CONTACT, contact); 
    219219        pj_xml_add_node(t, node); 
     
    230230 
    231231    if (!node) { 
    232         node = pj_pool_alloc(pool, sizeof(*node)); 
     232        node = PJ_POOL_ALLOC_T(pool, pj_xml_node); 
    233233        xml_init_node(pool, node, &CONTACT, NULL); 
    234234        pj_xml_add_node(t, node); 
     
    260260                                           const pj_str_t *text) 
    261261{ 
    262     pjpidf_note *note = pj_pool_alloc(pool, sizeof(*note)); 
     262    pjpidf_note *note = PJ_POOL_ALLOC_T(pool, pjpidf_note); 
    263263    xml_init_node(pool, note, &NOTE, text); 
    264264    pj_xml_add_node(t, note); 
     
    288288    pj_xml_node *node = pj_xml_find_node(t, &TIMESTAMP); 
    289289    if (!node) { 
    290         node = pj_pool_alloc(pool, sizeof(*node)); 
     290        node = PJ_POOL_ALLOC_T(pool, pj_xml_node); 
    291291        xml_init_node(pool, node, &TIMESTAMP, ts); 
    292292    } else { 
     
    301301    pj_xml_node *node = pj_xml_find_node(t, &TIMESTAMP); 
    302302    if (!node) { 
    303         node = pj_pool_alloc(pool, sizeof(*node)); 
     303        node = PJ_POOL_ALLOC_T(pool, pj_xml_node); 
    304304        xml_init_node(pool, node, &TIMESTAMP, ts); 
    305305    } else { 
     
    315315 
    316316    xml_init_node(pool, st, &STATUS, NULL); 
    317     node = pj_pool_alloc(pool, sizeof(*node)); 
     317    node = PJ_POOL_ALLOC_T(pool, pj_xml_node); 
    318318    xml_init_node(pool, node, &BASIC, &CLOSED); 
    319319    pj_xml_add_node(st, node); 
     
    336336PJ_DEF(pjpidf_pres*) pjpidf_create(pj_pool_t *pool, const pj_str_t *entity) 
    337337{ 
    338     pjpidf_pres *pres = pj_pool_alloc(pool, sizeof(*pres)); 
     338    pjpidf_pres *pres = PJ_POOL_ALLOC_T(pool, pjpidf_pres); 
    339339    pjpidf_pres_construct(pool, pres, entity); 
    340340    return pres; 
  • pjproject/trunk/pjsip/src/pjsip-simple/presence.c

    r974 r1241  
    198198 
    199199    /* Create presence */ 
    200     pres = pj_pool_zalloc(dlg->pool, sizeof(pjsip_pres)); 
     200    pres = PJ_POOL_ZALLOC_T(dlg->pool, pjsip_pres); 
    201201    pres->dlg = dlg; 
    202202    pres->sub = sub; 
     
    245245 
    246246    /* Check that Event header contains "presence" */ 
    247     event = pjsip_msg_find_hdr_by_name(rdata->msg_info.msg, &STR_EVENT, NULL); 
     247    event = (pjsip_event_hdr*) 
     248            pjsip_msg_find_hdr_by_name(rdata->msg_info.msg, &STR_EVENT, NULL); 
    248249    if (!event) { 
    249250        return PJSIP_ERRNO_FROM_SIP_STATUS(PJSIP_SC_BAD_REQUEST); 
     
    254255 
    255256    /* Check that request contains compatible Accept header. */ 
    256     accept = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_ACCEPT, NULL); 
     257    accept = (pjsip_accept_hdr*) 
     258             pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_ACCEPT, NULL); 
    257259    if (accept) { 
    258260        unsigned i; 
     
    281283 
    282284    /* Check that expires is not too short. */ 
    283     expires_hdr=pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_EXPIRES, NULL); 
     285    expires_hdr=(pjsip_expires_hdr*) 
     286                pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_EXPIRES, NULL); 
    284287    if (expires_hdr) { 
    285288        if (expires_hdr->ivalue < 5) { 
     
    305308 
    306309    /* Create server presence subscription */ 
    307     pres = pj_pool_zalloc(dlg->pool, sizeof(pjsip_pres)); 
     310    pres = PJ_POOL_ZALLOC_T(dlg->pool, pjsip_pres); 
    308311    pres->dlg = dlg; 
    309312    pres->sub = sub; 
     
    367370    PJ_ASSERT_RETURN(sub && status, PJ_EINVAL); 
    368371 
    369     pres = pjsip_evsub_get_mod_data(sub, mod_presence.id); 
     372    pres = (pjsip_pres*) pjsip_evsub_get_mod_data(sub, mod_presence.id); 
    370373    PJ_ASSERT_RETURN(pres!=NULL, PJSIP_SIMPLE_ENOPRESENCE); 
    371374 
     
    390393    PJ_ASSERT_RETURN(sub && status, PJ_EINVAL); 
    391394 
    392     pres = pjsip_evsub_get_mod_data(sub, mod_presence.id); 
     395    pres = (pjsip_pres*) pjsip_evsub_get_mod_data(sub, mod_presence.id); 
    393396    PJ_ASSERT_RETURN(pres!=NULL, PJSIP_SIMPLE_ENOPRESENCE); 
    394397 
     
    423426 
    424427    /* Get publisher URI */ 
    425     entity.ptr = pj_pool_alloc(tdata->pool, PJSIP_MAX_URL_SIZE); 
     428    entity.ptr = (char*) pj_pool_alloc(tdata->pool, PJSIP_MAX_URL_SIZE); 
    426429    entity.slen = pjsip_uri_print(PJSIP_URI_IN_REQ_URI, 
    427430                                  pres->dlg->local.info->uri, 
     
    463466 
    464467    /* Get the presence object. */ 
    465     pres = pjsip_evsub_get_mod_data(sub, mod_presence.id); 
     468    pres = (pjsip_pres*) pjsip_evsub_get_mod_data(sub, mod_presence.id); 
    466469    PJ_ASSERT_RETURN(pres != NULL, PJSIP_SIMPLE_ENOPRESENCE); 
    467470 
     
    509512 
    510513    /* Get the presence object. */ 
    511     pres = pjsip_evsub_get_mod_data(sub, mod_presence.id); 
     514    pres = (pjsip_pres*) pjsip_evsub_get_mod_data(sub, mod_presence.id); 
    512515    PJ_ASSERT_RETURN(pres != NULL, PJSIP_SIMPLE_ENOPRESENCE); 
    513516 
     
    559562    pjsip_pres *pres; 
    560563 
    561     pres = pjsip_evsub_get_mod_data(sub, mod_presence.id); 
     564    pres = (pjsip_pres*) pjsip_evsub_get_mod_data(sub, mod_presence.id); 
    562565    PJ_ASSERT_ON_FAIL(pres!=NULL, {return;}); 
    563566 
     
    574577    pjsip_pres *pres; 
    575578 
    576     pres = pjsip_evsub_get_mod_data(sub, mod_presence.id); 
     579    pres = (pjsip_pres*) pjsip_evsub_get_mod_data(sub, mod_presence.id); 
    577580    PJ_ASSERT_ON_FAIL(pres!=NULL, {return;}); 
    578581 
     
    594597    pjsip_pres *pres; 
    595598 
    596     pres = pjsip_evsub_get_mod_data(sub, mod_presence.id); 
     599    pres = (pjsip_pres*) pjsip_evsub_get_mod_data(sub, mod_presence.id); 
    597600    PJ_ASSERT_ON_FAIL(pres!=NULL, {return;}); 
    598601 
     
    722725    pj_status_t status; 
    723726 
    724     pres = pjsip_evsub_get_mod_data(sub, mod_presence.id); 
     727    pres = (pjsip_pres*) pjsip_evsub_get_mod_data(sub, mod_presence.id); 
    725728    PJ_ASSERT_ON_FAIL(pres!=NULL, {return;}); 
    726729 
     
    774777    pjsip_pres *pres; 
    775778 
    776     pres = pjsip_evsub_get_mod_data(sub, mod_presence.id); 
     779    pres = (pjsip_pres*) pjsip_evsub_get_mod_data(sub, mod_presence.id); 
    777780    PJ_ASSERT_ON_FAIL(pres!=NULL, {return;}); 
    778781 
     
    796799    pjsip_pres *pres; 
    797800 
    798     pres = pjsip_evsub_get_mod_data(sub, mod_presence.id); 
     801    pres = (pjsip_pres*) pjsip_evsub_get_mod_data(sub, mod_presence.id); 
    799802    PJ_ASSERT_ON_FAIL(pres!=NULL, {return;}); 
    800803 
  • pjproject/trunk/pjsip/src/pjsip-simple/presence_body.c

    r974 r1241  
    4343                           char *buf, pj_size_t size) 
    4444{ 
    45     return pj_xml_print(msg_body->data, buf, size, PJ_TRUE); 
     45    return pj_xml_print((const pj_xml_node*)msg_body->data, buf, size,  
     46                        PJ_TRUE); 
    4647} 
    4748 
     
    5354{ 
    5455    PJ_UNUSED_ARG(len); 
    55     return pj_xml_clone( pool, data); 
     56    return pj_xml_clone( pool, (const pj_xml_node*) data); 
    5657} 
    5758 
     
    101102    } 
    102103 
    103     body = pj_pool_zalloc(pool, sizeof(pjsip_msg_body)); 
     104    body = PJ_POOL_ZALLOC_T(pool, pjsip_msg_body); 
    104105    body->data = pidf; 
    105106    body->content_type.type = STR_APPLICATION; 
     
    140141        pjxpidf_set_status( xpidf, PJ_FALSE); 
    141142 
    142     body = pj_pool_zalloc(pool, sizeof(pjsip_msg_body)); 
     143    body = PJ_POOL_ZALLOC_T(pool, pjsip_msg_body); 
    143144    body->data = xpidf; 
    144145    body->content_type.type = STR_APPLICATION; 
     
    165166 
    166167    pidf = pjpidf_parse(rdata->tp_info.pool,  
    167                         rdata->msg_info.msg->body->data, 
     168                        (char*)rdata->msg_info.msg->body->data, 
    168169                        rdata->msg_info.msg->body->len); 
    169170    if (pidf == NULL) 
     
    210211 
    211212    xpidf = pjxpidf_parse(rdata->tp_info.pool,  
    212                           rdata->msg_info.msg->body->data, 
     213                          (char*)rdata->msg_info.msg->body->data, 
    213214                          rdata->msg_info.msg->body->len); 
    214215    if (xpidf == NULL) 
  • pjproject/trunk/pjsip/src/pjsip-simple/publishc.c

    r974 r1241  
    5151const pjsip_method pjsip_publish_method =  
    5252{ 
    53     PJSIP_PUBLISH_METHOD, 
     53    (pjsip_method_e)PJSIP_PUBLISH_METHOD, 
    5454    { "PUBLISH", 7 } 
    5555}; 
     
    123123    PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM); 
    124124 
    125     pubc = pj_pool_zalloc(pool, sizeof(struct pjsip_publishc)); 
     125    pubc = PJ_POOL_ZALLOC_T(pool, pjsip_publishc); 
    126126 
    127127    pubc->pool = pool; 
     
    292292        const pjsip_route_hdr *route; 
    293293 
    294         route_pos = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL); 
     294        route_pos = (pjsip_hdr*) 
     295                    pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL); 
    295296        if (!route_pos) 
    296297            route_pos = &tdata->msg->hdr; 
     
    298299        route = pubc->route_set.next; 
    299300        while (route != &pubc->route_set) { 
    300             pjsip_hdr *new_hdr = pjsip_hdr_shallow_clone(tdata->pool, route); 
     301            pjsip_hdr *new_hdr = (pjsip_hdr*) 
     302                                 pjsip_hdr_shallow_clone(tdata->pool, route); 
    301303            pj_list_insert_after(route_pos, new_hdr); 
    302304            route_pos = new_hdr; 
     
    346348        pjsip_hdr *dup; 
    347349 
    348         dup = pjsip_hdr_shallow_clone(tdata->pool, pubc->expires_hdr); 
     350        dup = (pjsip_hdr*) 
     351              pjsip_hdr_shallow_clone(tdata->pool, pubc->expires_hdr); 
    349352        if (dup) 
    350353            pjsip_msg_add_hdr(tdata->msg, dup); 
     
    425428                                   struct pj_timer_entry *entry) 
    426429{ 
    427     pjsip_publishc *pubc = entry->user_data; 
     430    pjsip_publishc *pubc = (pjsip_publishc*) entry->user_data; 
    428431    pjsip_tx_data *tdata; 
    429432    pj_status_t status; 
     
    447450{ 
    448451    pj_status_t status; 
    449     pjsip_publishc *pubc = token; 
     452    pjsip_publishc *pubc = (pjsip_publishc*) token; 
    450453    pjsip_transaction *tsx = event->body.tsx_state.tsx; 
    451454     
     
    508511 
    509512            /* Update expires value */ 
    510             expires = pjsip_msg_find_hdr(msg, PJSIP_H_EXPIRES, NULL); 
     513            expires = (pjsip_expires_hdr*) 
     514                      pjsip_msg_find_hdr(msg, PJSIP_H_EXPIRES, NULL); 
    511515 
    512516            if (expires) 
     
    575579    /* Increment CSeq */ 
    576580    cseq = ++pubc->cseq_hdr->cseq; 
    577     cseq_hdr = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_CSEQ, NULL); 
     581    cseq_hdr = (pjsip_cseq_hdr*) 
     582               pjsip_msg_find_hdr(tdata->msg, PJSIP_H_CSEQ, NULL); 
    578583    cseq_hdr->cseq = cseq; 
    579584 
  • pjproject/trunk/pjsip/src/pjsip-simple/xpidf.c

    r974 r1241  
    4141    pj_xml_node *node; 
    4242 
    43     node = pj_pool_alloc(pool, sizeof(pj_xml_node)); 
     43    node = PJ_POOL_ALLOC_T(pool, pj_xml_node); 
    4444    pj_list_init(&node->attr_head); 
    4545    pj_list_init(&node->node_head); 
     
    5454                                    const pj_str_t *value) 
    5555{ 
    56     pj_xml_attr *attr = pj_pool_alloc(pool, sizeof(*attr)); 
     56    pj_xml_attr *attr = PJ_POOL_ALLOC_T(pool, pj_xml_attr); 
    5757    attr->name = *name; 
    5858    pj_strdup(pool, &attr->value, value); 
     
    8080 
    8181    /* uri attribute */ 
    82     uri.ptr = pj_pool_alloc(pool, uri_cstr->slen + STR_SUBSCRIBE_PARAM.slen); 
     82    uri.ptr = (char*) pj_pool_alloc(pool, uri_cstr->slen +  
     83                                           STR_SUBSCRIBE_PARAM.slen); 
    8384    pj_strcpy( &uri, uri_cstr); 
    8485    pj_strcat( &uri, &STR_SUBSCRIBE_PARAM); 
  • pjproject/trunk/pjsip/src/pjsip/sip_tel_uri.c

    r974 r1241  
    7676                                     pj_bool_t parse_params); 
    7777 
    78 #ifdef __GNUC__ 
    79 #  define HAPPY_FLAG    (void*) 
    80 #else 
    81 #  define HAPPY_FLAG 
    82 #endif 
     78typedef const pj_str_t* (*P_GET_SCHEME)(const void*); 
     79typedef void*           (*P_GET_URI)(void*); 
     80typedef pj_ssize_t      (*P_PRINT_URI)(pjsip_uri_context_e,const void *, 
     81                                       char*,unsigned); 
     82typedef int             (*P_CMP_URI)(pjsip_uri_context_e, const void*,  
     83                                     const void*); 
     84typedef void*           (*P_CLONE)(pj_pool_t*, const void*); 
    8385 
    8486static pjsip_uri_vptr tel_uri_vptr =  
    8587{ 
    86     HAPPY_FLAG &tel_uri_get_scheme, 
    87     HAPPY_FLAG &tel_uri_get_uri, 
    88     HAPPY_FLAG &tel_uri_print, 
    89     HAPPY_FLAG &tel_uri_cmp, 
    90     HAPPY_FLAG &tel_uri_clone 
     88    (P_GET_SCHEME)      &tel_uri_get_scheme, 
     89    (P_GET_URI)         &tel_uri_get_uri, 
     90    (P_PRINT_URI)       &tel_uri_print, 
     91    (P_CMP_URI)         &tel_uri_cmp, 
     92    (P_CLONE)           &tel_uri_clone 
    9193}; 
    9294 
     
    9496PJ_DEF(pjsip_tel_uri*) pjsip_tel_uri_create(pj_pool_t *pool) 
    9597{ 
    96     pjsip_tel_uri *uri = pj_pool_zalloc(pool, sizeof(pjsip_tel_uri)); 
     98    pjsip_tel_uri *uri = PJ_POOL_ZALLOC_T(pool, pjsip_tel_uri); 
    9799    uri->vptr = &tel_uri_vptr; 
    98100    pj_list_init(&uri->other_param); 
     
    427429                uri->context = pvalue; 
    428430            } else { 
    429                 pjsip_param *param = pj_pool_alloc(pool, sizeof(pjsip_param)); 
     431                pjsip_param *param = PJ_POOL_ALLOC_T(pool, pjsip_param); 
    430432                param->name = pname; 
    431433                param->value = pvalue; 
  • pjproject/trunk/pjsip/src/pjsip/sip_transaction.c

    r1210 r1241  
    289289                   9 +                      /* Via port. */ 
    290290                   16;                      /* Separator+Allowance. */ 
    291     key = p = pj_pool_alloc(pool, len_required); 
     291    key = p = (char*) pj_pool_alloc(pool, len_required); 
    292292    end = p + len_required; 
    293293 
     
    356356    PJ_ASSERT_RETURN(pool && key && method && branch, PJ_EINVAL); 
    357357 
    358     p = key->ptr = pj_pool_alloc(pool, branch->slen + method->name.slen + 4 ); 
     358    p = key->ptr = (char*)  
     359                   pj_pool_alloc(pool, branch->slen + method->name.slen + 4 ); 
    359360     
    360361    /* Add role. */ 
     
    594595 
    595596    pj_mutex_lock(mod_tsx_layer.mutex); 
    596     tsx = pj_hash_get( mod_tsx_layer.htable, key->ptr, key->slen, &hval ); 
     597    tsx = (pjsip_transaction*) 
     598          pj_hash_get( mod_tsx_layer.htable, key->ptr, key->slen, &hval ); 
    597599    pj_mutex_unlock(mod_tsx_layer.mutex); 
    598600 
     
    645647    it = pj_hash_first(mod_tsx_layer.htable, &it_buf); 
    646648    while (it) { 
    647         pjsip_transaction *tsx = pj_hash_this(mod_tsx_layer.htable, it); 
     649        pjsip_transaction *tsx = (pjsip_transaction*)  
     650                                 pj_hash_this(mod_tsx_layer.htable, it); 
    648651        pj_hash_iterator_t *next = pj_hash_next(mod_tsx_layer.htable, it); 
    649652        if (tsx) { 
     
    706709    pj_mutex_lock( mod_tsx_layer.mutex ); 
    707710 
    708     tsx = pj_hash_get( mod_tsx_layer.htable, key.ptr, key.slen, &hval ); 
     711    tsx = (pjsip_transaction*)  
     712          pj_hash_get( mod_tsx_layer.htable, key.ptr, key.slen, &hval ); 
    709713 
    710714 
     
    754758    pj_mutex_lock( mod_tsx_layer.mutex ); 
    755759 
    756     tsx = pj_hash_get( mod_tsx_layer.htable, key.ptr, key.slen, &hval ); 
     760    tsx = (pjsip_transaction*)  
     761          pj_hash_get( mod_tsx_layer.htable, key.ptr, key.slen, &hval ); 
    757762 
    758763 
     
    792797PJ_DEF(pjsip_transaction*) pjsip_rdata_get_tsx( pjsip_rx_data *rdata ) 
    793798{ 
    794     return rdata->endpt_info.mod_data[mod_tsx_layer.mod.id]; 
     799    return (pjsip_transaction*)  
     800           rdata->endpt_info.mod_data[mod_tsx_layer.mod.id]; 
    795801} 
    796802 
     
    817823        } else { 
    818824            while (it != NULL) { 
    819                 pjsip_transaction *tsx = pj_hash_this(mod_tsx_layer.htable,it); 
     825                pjsip_transaction *tsx = (pjsip_transaction*)  
     826                                         pj_hash_this(mod_tsx_layer.htable,it); 
    820827 
    821828                PJ_LOG(3, (THIS_FILE, " %s %s|%d|%s", 
     
    895902        return PJ_ENOMEM; 
    896903 
    897     tsx = pj_pool_zalloc(pool, sizeof(pjsip_transaction)); 
     904    tsx = PJ_POOL_ZALLOC_T(pool, pjsip_transaction); 
    898905    tsx->pool = pool; 
    899906    tsx->tsx_user = tsx_user; 
     
    966973 
    967974    /* Clear TLS, so that mutex will not be unlocked */ 
    968     lck = pj_thread_local_get(pjsip_tsx_lock_tls_id); 
     975    lck = (struct tsx_lock_data*) pj_thread_local_get(pjsip_tsx_lock_tls_id); 
    969976    while (lck) { 
    970977        if (lck->tsx == tsx) { 
     
    990997{ 
    991998    pjsip_event event; 
    992     pjsip_transaction *tsx = entry->user_data; 
     999    pjsip_transaction *tsx = (pjsip_transaction*) entry->user_data; 
    9931000    struct tsx_lock_data lck; 
    9941001 
     
    10431050     */ 
    10441051    if (event_src_type==PJSIP_EVENT_RX_MSG && tsx->tsx_user) { 
    1045         pjsip_rx_data *rdata = event_src; 
     1052        pjsip_rx_data *rdata = (pjsip_rx_data*) event_src; 
    10461053 
    10471054        pj_assert(rdata != NULL); 
     
    11241131 
    11251132    /* Make sure CSeq header is present. */ 
    1126     cseq = pjsip_msg_find_hdr(msg, PJSIP_H_CSEQ, NULL); 
     1133    cseq = (pjsip_cseq_hdr*) pjsip_msg_find_hdr(msg, PJSIP_H_CSEQ, NULL); 
    11271134    if (!cseq) { 
    11281135        pj_assert(!"CSeq header not present in outgoing message!"); 
     
    11501157 
    11511158    /* Generate Via header if it doesn't exist. */ 
    1152     via = pjsip_msg_find_hdr(msg, PJSIP_H_VIA, NULL); 
     1159    via = (pjsip_via_hdr*) pjsip_msg_find_hdr(msg, PJSIP_H_VIA, NULL); 
    11531160    if (via == NULL) { 
    11541161        via = pjsip_via_hdr_create(tdata->pool); 
     
    11591166    if (via->branch_param.slen == 0) { 
    11601167        pj_str_t tmp; 
    1161         via->branch_param.ptr = pj_pool_alloc(tsx->pool, PJSIP_MAX_BRANCH_LEN); 
     1168        via->branch_param.ptr = (char*) 
     1169                                pj_pool_alloc(tsx->pool, PJSIP_MAX_BRANCH_LEN); 
    11621170        via->branch_param.slen = PJSIP_MAX_BRANCH_LEN; 
    11631171        pj_memcpy(via->branch_param.ptr, PJSIP_RFC3261_BRANCH_ID,  
     
    15101518                               pj_ssize_t sent, pj_bool_t *cont ) 
    15111519{ 
    1512     pjsip_transaction *tsx = send_state->token; 
     1520    pjsip_transaction *tsx = (pjsip_transaction*) send_state->token; 
    15131521    struct tsx_lock_data lck; 
    15141522 
     
    16301638{ 
    16311639    if (sent < 0) { 
    1632         pjsip_transaction *tsx = token; 
     1640        pjsip_transaction *tsx = (pjsip_transaction*) token; 
    16331641        struct tsx_lock_data lck; 
    16341642        char errmsg[PJ_ERR_MSG_SIZE]; 
     
    22742282             */ 
    22752283            if (!tsx->is_reliable) { 
    2276                 pjsip_cseq_hdr *cseq = pjsip_msg_find_hdr( msg, PJSIP_H_CSEQ, 
     2284                pjsip_cseq_hdr *cseq = (pjsip_cseq_hdr*) 
     2285                                       pjsip_msg_find_hdr( msg, PJSIP_H_CSEQ, 
    22772286                                                           NULL); 
    22782287                if (cseq->method.id == PJSIP_INVITE_METHOD) { 
  • pjproject/trunk/pjsip/src/pjsip/sip_transport.c

    r1080 r1241  
    315315        return PJ_ENOMEM; 
    316316 
    317     tdata = pj_pool_zalloc(pool, sizeof(pjsip_tx_data)); 
     317    tdata = PJ_POOL_ZALLOC_T(pool, pjsip_tx_data); 
    318318    tdata->pool = pool; 
    319319    tdata->mgr = mgr; 
     
    397397    int len; 
    398398 
    399     cseq = pjsip_msg_find_hdr(msg, PJSIP_H_CSEQ, NULL); 
     399    cseq = (const pjsip_cseq_hdr*) pjsip_msg_find_hdr(msg, PJSIP_H_CSEQ, NULL); 
    400400    PJ_ASSERT_RETURN(cseq != NULL, "INVALID MSG"); 
    401401 
     
    419419    } 
    420420 
    421     info = pj_pool_alloc(pool, len+1); 
     421    info = (char*) pj_pool_alloc(pool, len+1); 
    422422    pj_memcpy(info, info_buf, len+1); 
    423423 
     
    493493                                    pj_ssize_t size) 
    494494{ 
    495     pjsip_tx_data *tdata = token; 
     495    pjsip_tx_data *tdata = (pjsip_tx_data*) token; 
    496496 
    497497    PJ_UNUSED_ARG(transport); 
     
    518518    /* Allocate buffer if necessary. */ 
    519519    if (tdata->buf.start == NULL) { 
    520         tdata->buf.start = pj_pool_alloc( tdata->pool, PJSIP_MAX_PKT_LEN); 
     520        tdata->buf.start = (char*)  
     521                           pj_pool_alloc( tdata->pool, PJSIP_MAX_PKT_LEN); 
    521522        tdata->buf.cur = tdata->buf.start; 
    522523        tdata->buf.end = tdata->buf.start + PJSIP_MAX_PKT_LEN; 
     
    613614                                    struct pj_timer_entry *entry) 
    614615{ 
    615     pjsip_transport *tp = entry->user_data; 
     616    pjsip_transport *tp = (pjsip_transport*) entry->user_data; 
    616617    pj_assert(tp != NULL); 
    617618 
     
    901902 
    902903    /* Create and initialize transport manager. */ 
    903     mgr = pj_pool_zalloc(pool, sizeof(*mgr)); 
     904    mgr = PJ_POOL_ZALLOC_T(pool, pjsip_tpmgr); 
    904905    mgr->endpt = endpt; 
    905906    mgr->on_rx_msg = rx_cb; 
     
    10361037        pjsip_transport *transport; 
    10371038         
    1038         transport = pj_hash_this(mgr->table, itr); 
     1039        transport = (pjsip_transport*) pj_hash_this(mgr->table, itr); 
    10391040 
    10401041        next = pj_hash_next(mgr->table, itr); 
     
    13441345        pj_memcpy(&key.addr, remote, addr_len); 
    13451346 
    1346         transport = pj_hash_get(mgr->table, &key, key_len, NULL); 
     1347        transport = (pjsip_transport*) 
     1348                    pj_hash_get(mgr->table, &key, key_len, NULL); 
    13471349        if (transport == NULL) { 
    13481350            unsigned flag = pjsip_transport_get_flag_from_type(type); 
     
    13571359                pj_bzero(addr, sizeof(pj_sockaddr_in)); 
    13581360                key_len = sizeof(key.type) + sizeof(pj_sockaddr_in); 
    1359                 transport = pj_hash_get(mgr->table, &key, key_len, NULL); 
     1361                transport = (pjsip_transport*)  
     1362                            pj_hash_get(mgr->table, &key, key_len, NULL); 
    13601363            } 
    13611364            /* For datagram INET transports, try lookup with zero address. 
     
    13701373 
    13711374                key_len = sizeof(key.type) + sizeof(pj_sockaddr_in); 
    1372                 transport = pj_hash_get(mgr->table, &key, key_len, NULL); 
     1375                transport = (pjsip_transport*) 
     1376                            pj_hash_get(mgr->table, &key, key_len, NULL); 
    13731377            } 
    13741378        } 
     
    14111415    /* Request factory to create transport. */ 
    14121416    status = factory->create_transport(factory, mgr, mgr->endpt, 
    1413                                        remote, addr_len, tp); 
     1417                                       (const pj_sockaddr*) remote, addr_len, 
     1418                                       tp); 
    14141419    if (status == PJ_SUCCESS) { 
    14151420        PJ_ASSERT_ON_FAIL(tp!=NULL,  
     
    14551460 
    14561461        do { 
    1457             pjsip_transport *t = pj_hash_this(mgr->table, itr); 
     1462            pjsip_transport *t = (pjsip_transport*)  
     1463                                 pj_hash_this(mgr->table, itr); 
    14581464 
    14591465            PJ_LOG(3, (THIS_FILE, "  %s %s (refcnt=%d%s)",  
  • pjproject/trunk/pjsip/src/pjsip/sip_transport_loop.c

    r974 r1241  
    7979        return NULL; 
    8080 
    81     pkt = pj_pool_zalloc(pool, sizeof(struct recv_list)); 
     81    pkt = PJ_POOL_ZALLOC_T(pool, struct recv_list); 
    8282 
    8383    /* Initialize rdata. */ 
     
    121121    pjsip_tx_data_add_ref(tdata); 
    122122    pj_lock_acquire(tdata->lock); 
    123     sent_status = pj_pool_alloc(tdata->pool, sizeof(struct send_list)); 
     123    sent_status = PJ_POOL_ALLOC_T(tdata->pool, struct send_list); 
    124124    pj_lock_release(tdata->lock); 
    125125 
     
    254254static int loop_transport_worker_thread(void *arg) 
    255255{ 
    256     struct loop_transport *loop = arg; 
     256    struct loop_transport *loop = (struct loop_transport*) arg; 
    257257    struct recv_list r; 
    258258    struct send_list s; 
     
    357357 
    358358    /* Create the loop structure. */ 
    359     loop = pj_pool_zalloc(pool, sizeof(struct loop_transport)); 
     359    loop = PJ_POOL_ZALLOC_T(pool, struct loop_transport); 
    360360     
    361361    /* Initialize transport properties. */ 
  • pjproject/trunk/pjsip/src/pjsip/sip_transport_tcp.c

    r1159 r1241  
    171171{ 
    172172    enum { M = 48 }; 
    173     host_port->host.ptr = pj_pool_alloc(pool, M); 
     173    host_port->host.ptr = (char*) pj_pool_alloc(pool, M); 
    174174    host_port->host.slen = pj_ansi_snprintf( host_port->host.ptr, M, "%s",  
    175175                                            pj_inet_ntoa(addr->sin_addr)); 
     
    223223 
    224224 
    225     listener = pj_pool_zalloc(pool, sizeof(struct tcp_listener)); 
     225    listener = PJ_POOL_ZALLOC_T(pool, struct tcp_listener); 
    226226    listener->factory.pool = pool; 
    227227    listener->factory.type = PJSIP_TRANSPORT_TCP; 
     
    346346        } 
    347347 
    348         listener->accept_op[i] = pj_pool_zalloc(pool,  
    349                                                 sizeof(struct pending_accept)); 
     348        listener->accept_op[i] = PJ_POOL_ZALLOC_T(pool,  
     349                                                  struct pending_accept); 
    350350        pj_ioqueue_op_key_init(&listener->accept_op[i]->op_key,  
    351351                                sizeof(listener->accept_op[i]->op_key)); 
     
    508508     * Create and initialize basic transport structure. 
    509509     */ 
    510     tcp = pj_pool_zalloc(pool, sizeof(*tcp)); 
     510    tcp = PJ_POOL_ZALLOC_T(pool, struct tcp_transport); 
    511511    tcp->sock = sock; 
    512512    tcp->is_server = is_server; 
     
    533533    tcp->base.flag = pjsip_transport_get_flag_from_type(PJSIP_TRANSPORT_TCP); 
    534534 
    535     tcp->base.info = pj_pool_alloc(pool, 64); 
     535    tcp->base.info = (char*) pj_pool_alloc(pool, 64); 
    536536    pj_ansi_snprintf(tcp->base.info, 64, "TCP to %s:%d", 
    537537                     pj_inet_ntoa(remote->sin_addr),  
     
    890890    int err_cnt = 0; 
    891891 
    892     listener = pj_ioqueue_get_user_data(key); 
     892    listener = (struct tcp_listener*) pj_ioqueue_get_user_data(key); 
    893893    accept_op = (struct pending_accept*) op_key; 
    894894 
     
    949949            pool = pjsip_endpt_create_pool(listener->endpt, "tcps%p",  
    950950                                           POOL_TP_INIT, POOL_TP_INC); 
    951             new_op = pj_pool_zalloc(pool, sizeof(struct pending_accept)); 
     951            new_op = PJ_POOL_ZALLOC_T(pool, struct pending_accept); 
    952952            new_op->pool = pool; 
    953953            new_op->listener = listener; 
     
    10031003                              pj_ssize_t bytes_sent) 
    10041004{ 
    1005     struct tcp_transport *tcp = pj_ioqueue_get_user_data(key); 
     1005    struct tcp_transport *tcp = (struct tcp_transport*)  
     1006                                pj_ioqueue_get_user_data(key); 
    10061007    pjsip_tx_data_op_key *tdata_op_key = (pjsip_tx_data_op_key*)op_key; 
    10071008 
     
    10821083             * the delayed list. 
    10831084             */ 
    1084             delayed_tdata = pj_pool_alloc(tdata->pool,  
    1085                                           sizeof(*delayed_tdata)); 
     1085            delayed_tdata = PJ_POOL_ALLOC_T(tdata->pool,  
     1086                                            struct delayed_tdata); 
    10861087            delayed_tdata->tdata_op_key = &tdata->op_key; 
    10871088 
     
    12931294    int addrlen; 
    12941295 
    1295     tcp = pj_ioqueue_get_user_data(key); 
     1296    tcp = (struct tcp_transport*) pj_ioqueue_get_user_data(key); 
    12961297 
    12971298    /* Mark that pending connect() operation has completed. */ 
  • pjproject/trunk/pjsip/src/pjsip/sip_transport_udp.c

    r1080 r1241  
    8383    //pj_pool_reset(pool); 
    8484 
    85     rdata = pj_pool_zalloc(pool, sizeof(pjsip_rx_data)); 
     85    rdata = PJ_POOL_ZALLOC_T(pool, pjsip_rx_data); 
    8686 
    8787    /* Init tp_info part. */ 
     
    262262                                   pj_ssize_t bytes_sent) 
    263263{ 
    264     struct udp_transport *tp = pj_ioqueue_get_user_data(key); 
     264    struct udp_transport *tp = (struct udp_transport*)  
     265                               pj_ioqueue_get_user_data(key); 
    265266    pjsip_tx_data_op_key *tdata_op_key = (pjsip_tx_data_op_key*)op_key; 
    266267 
     
    447448 
    448449    /* Create the UDP transport object. */ 
    449     tp = pj_pool_zalloc(pool, sizeof(struct udp_transport)); 
     450    tp = PJ_POOL_ZALLOC_T(pool, struct udp_transport); 
    450451 
    451452    /* Save pool. */ 
     
    497498 
    498499    /* Transport info. */ 
    499     tp->base.info = pj_pool_alloc(pool, M); 
     500    tp->base.info = (char*) pj_pool_alloc(pool, M); 
    500501    pj_ansi_snprintf(  
    501502        tp->base.info, M, "udp %s:%d [published as %s:%d]", 
     
    543544    /* Create rdata and put it in the array. */ 
    544545    tp->rdata_cnt = 0; 
    545     tp->rdata = pj_pool_calloc(tp->base.pool, async_cnt,  
     546    tp->rdata = (pjsip_rx_data**) 
     547                pj_pool_calloc(tp->base.pool, async_cnt,  
    546548                               sizeof(pjsip_rx_data*)); 
    547549    for (i=0; i<async_cnt; ++i) { 
  • pjproject/trunk/pjsip/src/pjsip/sip_ua_layer.c

    r989 r1241  
    166166 
    167167    /* Get the dialog where this transaction belongs. */ 
    168     dlg = tsx->mod_data[mod_ua.mod.id]; 
     168    dlg = (pjsip_dialog*) tsx->mod_data[mod_ua.mod.id]; 
    169169     
    170170    /* If dialog instance has gone, it could mean that the dialog 
     
    245245 
    246246    set_key->slen = call_id->slen + local_tag->slen + 1; 
    247     set_key->ptr = pj_pool_alloc(pool, set_key->slen); 
     247    set_key->ptr = (char*) pj_pool_alloc(pool, set_key->slen); 
    248248    pj_assert(set_key->ptr != NULL); 
    249249 
     
    268268        return set; 
    269269    } else { 
    270         set = pj_pool_alloc(mod_ua.pool, sizeof(struct dlg_set)); 
     270        set = PJ_POOL_ALLOC_T(mod_ua.pool, struct dlg_set); 
    271271        return set; 
    272272    } 
     
    299299        struct dlg_set *dlg_set; 
    300300 
    301         dlg_set = pj_hash_get( mod_ua.dlg_table, dlg->local.info->tag.ptr,  
     301        dlg_set = (struct dlg_set*) 
     302                  pj_hash_get( mod_ua.dlg_table, dlg->local.info->tag.ptr,  
    302303                               dlg->local.info->tag.slen, 
    303304                               &dlg->local.tag_hval); 
     
    367368 
    368369    /* Find this dialog from the dialog set. */ 
    369     dlg_set = dlg->dlg_set; 
     370    dlg_set = (struct dlg_set*) dlg->dlg_set; 
    370371    d = dlg_set->dlg_list.next; 
    371372    while (d != (pjsip_dialog*)&dlg_set->dlg_list && d != dlg) { 
     
    401402PJ_DEF(pjsip_dialog*) pjsip_rdata_get_dlg( pjsip_rx_data *rdata ) 
    402403{ 
    403     return rdata->endpt_info.mod_data[mod_ua.mod.id]; 
     404    return (pjsip_dialog*) rdata->endpt_info.mod_data[mod_ua.mod.id]; 
    404405} 
    405406 
    406407PJ_DEF(pjsip_dialog*) pjsip_tsx_get_dlg( pjsip_transaction *tsx ) 
    407408{ 
    408     return tsx->mod_data[mod_ua.mod.id]; 
     409    return (pjsip_dialog*) tsx->mod_data[mod_ua.mod.id]; 
    409410} 
    410411 
     
    427428 
    428429    /* Lookup the dialog set. */ 
    429     dlg_set = pj_hash_get(mod_ua.dlg_table, local_tag->ptr, local_tag->slen, 
     430    dlg_set = (struct dlg_set*) 
     431              pj_hash_get(mod_ua.dlg_table, local_tag->ptr, local_tag->slen, 
    430432                          NULL); 
    431433    if (dlg_set == NULL) { 
     
    517519        /* We should find the dialog attached to the INVITE transaction */ 
    518520        if (tsx) { 
    519             dlg = tsx->mod_data[mod_ua.mod.id]; 
     521            dlg = (pjsip_dialog*) tsx->mod_data[mod_ua.mod.id]; 
    520522            pj_mutex_unlock(tsx->mutex); 
    521523 
     
    523525             * (e.g. during debugging where initially there is a dialog) 
    524526             */ 
    525             return dlg ? dlg->dlg_set : NULL; 
     527            return dlg ? (struct dlg_set*) dlg->dlg_set : NULL; 
    526528 
    527529        } else { 
     
    540542 
    541543        /* Lookup the dialog set. */ 
    542         dlg_set = pj_hash_get(mod_ua.dlg_table, tag->ptr, tag->slen, NULL); 
     544        dlg_set = (struct dlg_set*) 
     545                  pj_hash_get(mod_ua.dlg_table, tag->ptr, tag->slen, NULL); 
    543546        return dlg_set; 
    544547    } 
     
    705708 
    706709        /* Get the dialog set. */ 
    707         dlg_set = dlg->dlg_set; 
     710        dlg_set = (struct dlg_set*) dlg->dlg_set; 
    708711 
    709712        /* Even if transaction is found and (candidate) dialog has been  
     
    733736 
    734737        /* Get the dialog set. */ 
    735         dlg_set = pj_hash_get(mod_ua.dlg_table,  
     738        dlg_set = (struct dlg_set*) 
     739                  pj_hash_get(mod_ua.dlg_table,  
    736740                              rdata->msg_info.from->tag.ptr, 
    737741                              rdata->msg_info.from->tag.slen, 
     
    918922            const char *title; 
    919923 
    920             dlg_set = pj_hash_this(mod_ua.dlg_table, it); 
     924            dlg_set = (struct dlg_set*) pj_hash_this(mod_ua.dlg_table, it); 
    921925            if (!dlg_set || pj_list_empty(&dlg_set->dlg_list)) continue; 
    922926 
  • pjproject/trunk/pjsip/src/pjsip/sip_uri.c

    r1221 r1241  
    6161    pj_list_init(dst_list); 
    6262    while (p != src_list) { 
    63         pjsip_param *new_param = pj_pool_alloc(pool, sizeof(pjsip_param)); 
     63        pjsip_param *new_param = PJ_POOL_ALLOC_T(pool, pjsip_param); 
    6464        pj_strdup(pool, &new_param->name, &p->name); 
    6565        pj_strdup(pool, &new_param->value, &p->value); 
     
    7878    pj_list_init(dst_list); 
    7979    while (p != src_list) { 
    80         pjsip_param *new_param = pj_pool_alloc(pool, sizeof(pjsip_param)); 
     80        pjsip_param *new_param = PJ_POOL_ALLOC_T(pool, pjsip_param); 
    8181        new_param->name = p->name; 
    8282        new_param->value = p->value; 
     
    137137static pj_str_t sip_str = { "sip", 3 }; 
    138138static pj_str_t sips_str = { "sips", 4 }; 
    139  
    140 #ifdef __GNUC__ 
    141 #  define HAPPY_FLAG    (void*) 
    142 #else 
    143 #  define HAPPY_FLAG 
    144 #endif 
    145139 
    146140static pjsip_name_addr* pjsip_name_addr_clone( pj_pool_t *pool,  
     
    161155                                      const pjsip_sip_uri *rhs); 
    162156 
     157typedef const pj_str_t* (*P_GET_SCHEME)(const void*); 
     158typedef void*           (*P_GET_URI)(void*); 
     159typedef pj_ssize_t      (*P_PRINT_URI)(pjsip_uri_context_e,const void *, 
     160                                       char*,unsigned); 
     161typedef int             (*P_CMP_URI)(pjsip_uri_context_e, const void*,  
     162                                     const void*); 
     163typedef void*           (*P_CLONE)(pj_pool_t*, const void*); 
     164 
     165 
    163166static pjsip_uri_vptr sip_url_vptr =  
    164167{ 
    165     HAPPY_FLAG &pjsip_url_get_scheme, 
    166     HAPPY_FLAG &pjsip_get_uri, 
    167     HAPPY_FLAG &pjsip_url_print, 
    168     HAPPY_FLAG &pjsip_url_compare, 
    169     HAPPY_FLAG &pjsip_url_clone 
     168    (P_GET_SCHEME)      &pjsip_url_get_scheme, 
     169    (P_GET_URI)         &pjsip_get_uri, 
     170    (P_PRINT_URI)       &pjsip_url_print, 
     171    (P_CMP_URI)         &pjsip_url_compare, 
     172    (P_CLONE)           &pjsip_url_clone 
    170173}; 
    171174 
    172175static pjsip_uri_vptr sips_url_vptr =  
    173176{ 
    174     HAPPY_FLAG &pjsips_url_get_scheme, 
    175     HAPPY_FLAG &pjsip_get_uri, 
    176     HAPPY_FLAG &pjsip_url_print, 
    177     HAPPY_FLAG &pjsip_url_compare, 
    178     HAPPY_FLAG &pjsip_url_clone 
     177    (P_GET_SCHEME)      &pjsips_url_get_scheme, 
     178    (P_GET_URI)         &pjsip_get_uri, 
     179    (P_PRINT_URI)       &pjsip_url_print, 
     180    (P_CMP_URI)         &pjsip_url_compare, 
     181    (P_CLONE)           &pjsip_url_clone 
    179182}; 
    180183 
    181184static pjsip_uri_vptr name_addr_vptr =  
    182185{ 
    183     HAPPY_FLAG &pjsip_name_addr_get_scheme, 
    184     HAPPY_FLAG &pjsip_name_addr_get_uri, 
    185     HAPPY_FLAG &pjsip_name_addr_print, 
    186     HAPPY_FLAG &pjsip_name_addr_compare, 
    187     HAPPY_FLAG &pjsip_name_addr_clone 
     186    (P_GET_SCHEME)      &pjsip_name_addr_get_scheme, 
     187    (P_GET_URI)         &pjsip_name_addr_get_uri, 
     188    (P_PRINT_URI)       &pjsip_name_addr_print, 
     189    (P_CMP_URI)         &pjsip_name_addr_compare, 
     190    (P_CLONE)           &pjsip_name_addr_clone 
    188191}; 
    189192 
     
    228231                                             pj_bool_t secure ) 
    229232{ 
    230     pjsip_sip_uri *url = pj_pool_alloc(pool, sizeof(pjsip_sip_uri)); 
     233    pjsip_sip_uri *url = PJ_POOL_ALLOC_T(pool, pjsip_sip_uri); 
    231234    pjsip_sip_uri_init(url, secure); 
    232235    return url; 
     
    497500static pjsip_sip_uri* pjsip_url_clone(pj_pool_t *pool, const pjsip_sip_uri *rhs) 
    498501{ 
    499     pjsip_sip_uri *url = pj_pool_alloc(pool, sizeof(pjsip_sip_uri)); 
     502    pjsip_sip_uri *url = PJ_POOL_ALLOC_T(pool, pjsip_sip_uri); 
    500503    if (!url) 
    501504        return NULL; 
     
    521524PJ_DEF(pjsip_name_addr*) pjsip_name_addr_create(pj_pool_t *pool) 
    522525{ 
    523     pjsip_name_addr *name_addr = pj_pool_alloc(pool, sizeof(pjsip_name_addr)); 
     526    pjsip_name_addr *name_addr = PJ_POOL_ALLOC_T(pool, pjsip_name_addr); 
    524527    pjsip_name_addr_init(name_addr); 
    525528    return name_addr; 
     
    535538    pjsip_uri *uri; 
    536539 
    537     uri = pjsip_uri_get_uri(name->uri); 
     540    uri = (pjsip_uri*) pjsip_uri_get_uri(name->uri); 
    538541    pj_assert(uri != NULL); 
    539542 
     
    566569{ 
    567570    pj_strdup( pool, &dst->display, &src->display); 
    568     dst->uri = pjsip_uri_clone(pool, src->uri); 
     571    dst->uri = (pjsip_uri*) pjsip_uri_clone(pool, src->uri); 
    569572} 
    570573 
     
    572575                                               const pjsip_name_addr *rhs) 
    573576{ 
    574     pjsip_name_addr *addr = pj_pool_alloc(pool, sizeof(pjsip_name_addr)); 
     577    pjsip_name_addr *addr = PJ_POOL_ALLOC_T(pool, pjsip_name_addr); 
    575578    if (!addr) 
    576579        return NULL; 
  • pjproject/trunk/pjsip/src/pjsip/sip_util.c

    r1127 r1241  
    8585    endpt_hdr = pjsip_endpt_get_request_headers(endpt)->next; 
    8686    while (endpt_hdr != pjsip_endpt_get_request_headers(endpt)) { 
    87         pjsip_hdr *hdr = pjsip_hdr_shallow_clone(tdata->pool, endpt_hdr); 
     87        pjsip_hdr *hdr = (pjsip_hdr*)  
     88                         pjsip_hdr_shallow_clone(tdata->pool, endpt_hdr); 
    8889        pjsip_msg_add_hdr( tdata->msg, hdr ); 
    8990        endpt_hdr = endpt_hdr->next; 
     
    9394    if (param_from->tag.slen == 0) 
    9495        pj_create_unique_string(tdata->pool, &param_from->tag); 
    95     pjsip_msg_add_hdr(msg, (void*)param_from); 
     96    pjsip_msg_add_hdr(msg, (pjsip_hdr*)param_from); 
    9697 
    9798    /* Add To header. */ 
    98     pjsip_msg_add_hdr(msg, (void*)param_to); 
     99    pjsip_msg_add_hdr(msg, (pjsip_hdr*)param_to); 
    99100 
    100101    /* Add Contact header. */ 
    101102    if (param_contact) { 
    102         pjsip_msg_add_hdr(msg, (void*)param_contact); 
     103        pjsip_msg_add_hdr(msg, (pjsip_hdr*)param_contact); 
    103104    } 
    104105 
    105106    /* Add Call-ID header. */ 
    106     pjsip_msg_add_hdr(msg, (void*)param_call_id); 
     107    pjsip_msg_add_hdr(msg, (pjsip_hdr*)param_call_id); 
    107108 
    108109    /* Add CSeq header. */ 
    109     pjsip_msg_add_hdr(msg, (void*)param_cseq); 
     110    pjsip_msg_add_hdr(msg, (pjsip_hdr*)param_cseq); 
    110111 
    111112    /* Add a blank Via header in the front of the message. */ 
    112113    via = pjsip_via_hdr_create(tdata->pool); 
    113114    via->rport_param = 0; 
    114     pjsip_msg_insert_first_hdr(msg, (void*)via); 
     115    pjsip_msg_insert_first_hdr(msg, (pjsip_hdr*)via); 
    115116 
    116117    /* Add header params as request headers */ 
     
    135136    /* Create message body. */ 
    136137    if (param_text) { 
    137         body = pj_pool_calloc(tdata->pool, 1, sizeof(pjsip_msg_body)); 
     138        body = PJ_POOL_ZALLOC_T(tdata->pool, pjsip_msg_body); 
    138139        body->content_type.type = str_TEXT; 
    139140        body->content_type.subtype = str_PLAIN; 
     
    297298    PJ_TRY { 
    298299        /* Duplicate target URI and headers. */ 
    299         target = pjsip_uri_clone(tdata->pool, param_target); 
    300         from = pjsip_hdr_clone(tdata->pool, param_from); 
     300        target = (pjsip_uri*) pjsip_uri_clone(tdata->pool, param_target); 
     301        from = (pjsip_from_hdr*) pjsip_hdr_clone(tdata->pool, param_from); 
    301302        pjsip_fromto_hdr_set_from(from); 
    302         to = pjsip_hdr_clone(tdata->pool, param_to); 
     303        to = (pjsip_to_hdr*) pjsip_hdr_clone(tdata->pool, param_to); 
    303304        pjsip_fromto_hdr_set_to(to); 
    304         if (param_contact) 
    305             contact = pjsip_hdr_clone(tdata->pool, param_contact); 
    306         else 
     305        if (param_contact) { 
     306            contact = (pjsip_contact_hdr*)  
     307                      pjsip_hdr_clone(tdata->pool, param_contact); 
     308        } else { 
    307309            contact = NULL; 
    308         call_id = pjsip_hdr_clone(tdata->pool, param_call_id); 
     310        } 
     311        call_id = (pjsip_cid_hdr*) pjsip_hdr_clone(tdata->pool, param_call_id); 
    309312        cseq = pjsip_cseq_hdr_create(tdata->pool); 
    310313        if (param_cseq >= 0) 
     
    386389    via = rdata->msg_info.via; 
    387390    while (via) { 
    388         pjsip_msg_add_hdr( msg, pjsip_hdr_clone(tdata->pool, via)); 
     391        pjsip_msg_add_hdr( msg, (pjsip_hdr*)pjsip_hdr_clone(tdata->pool, via)); 
    389392        via = via->next; 
    390393        if (via != (void*)&req_msg->hdr) 
    391             via = pjsip_msg_find_hdr(req_msg, PJSIP_H_VIA, via); 
     394            via = (pjsip_via_hdr*)  
     395                  pjsip_msg_find_hdr(req_msg, PJSIP_H_VIA, via); 
    392396        else 
    393397            break; 
     
    395399 
    396400    /* Copy all Record-Route headers, in order. */ 
    397     rr = pjsip_msg_find_hdr(req_msg, PJSIP_H_RECORD_ROUTE, NULL); 
     401    rr = (pjsip_rr_hdr*)  
     402         pjsip_msg_find_hdr(req_msg, PJSIP_H_RECORD_ROUTE, NULL); 
    398403    while (rr) { 
    399         pjsip_msg_add_hdr(msg, pjsip_hdr_clone(tdata->pool, rr)); 
     404        pjsip_msg_add_hdr(msg, (pjsip_hdr*) pjsip_hdr_clone(tdata->pool, rr)); 
    400405        rr = rr->next; 
    401406        if (rr != (void*)&req_msg->hdr) 
    402             rr = pjsip_msg_find_hdr(req_msg, PJSIP_H_RECORD_ROUTE, rr); 
     407            rr = (pjsip_rr_hdr*) pjsip_msg_find_hdr(req_msg,  
     408                                                    PJSIP_H_RECORD_ROUTE, rr); 
    403409        else 
    404410            break; 
     
    406412 
    407413    /* Copy Call-ID header. */ 
    408     hdr = pjsip_msg_find_hdr( req_msg, PJSIP_H_CALL_ID, NULL); 
    409     pjsip_msg_add_hdr(msg, pjsip_hdr_clone(tdata->pool, hdr)); 
     414    hdr = (pjsip_hdr*) pjsip_msg_find_hdr( req_msg, PJSIP_H_CALL_ID, NULL); 
     415    pjsip_msg_add_hdr(msg, (pjsip_hdr*) pjsip_hdr_clone(tdata->pool, hdr)); 
    410416 
    411417    /* Copy From header. */ 
    412     hdr = pjsip_hdr_clone(tdata->pool, rdata->msg_info.from); 
     418    hdr = (pjsip_hdr*) pjsip_hdr_clone(tdata->pool, rdata->msg_info.from); 
    413419    pjsip_msg_add_hdr( msg, hdr); 
    414420 
    415421    /* Copy To header. */ 
    416     hdr = pjsip_hdr_clone(tdata->pool, rdata->msg_info.to); 
     422    hdr = (pjsip_hdr*) pjsip_hdr_clone(tdata->pool, rdata->msg_info.to); 
    417423    pjsip_msg_add_hdr( msg, hdr); 
    418424 
    419425    /* Copy CSeq header. */ 
    420     hdr = pjsip_hdr_clone(tdata->pool, rdata->msg_info.cseq); 
     426    hdr = (pjsip_hdr*) pjsip_hdr_clone(tdata->pool, rdata->msg_info.cseq); 
    421427    pjsip_msg_add_hdr( msg, hdr); 
    422428 
     
    495501 
    496502    /* Clear Via headers in the new request. */ 
    497     while ((via=pjsip_msg_find_hdr(ack->msg, PJSIP_H_VIA, NULL)) != NULL) 
     503    while ((via=(pjsip_hdr*)pjsip_msg_find_hdr(ack->msg, PJSIP_H_VIA, NULL)) != NULL) 
    498504        pj_list_erase(via); 
    499505 
    500506    /* Must contain single Via, just as the original INVITE. */ 
    501     hdr = pjsip_msg_find_hdr( invite_msg, PJSIP_H_VIA, NULL); 
    502     pjsip_msg_insert_first_hdr( ack->msg, pjsip_hdr_clone(ack->pool,hdr) ); 
     507    hdr = (pjsip_hdr*) pjsip_msg_find_hdr( invite_msg, PJSIP_H_VIA, NULL); 
     508    pjsip_msg_insert_first_hdr( ack->msg,  
     509                                (pjsip_hdr*) pjsip_hdr_clone(ack->pool,hdr) ); 
    503510 
    504511    /* If the original INVITE has Route headers, those header fields MUST  
    505512     * appear in the ACK. 
    506513     */ 
    507     hdr = pjsip_msg_find_hdr( invite_msg, PJSIP_H_ROUTE, NULL); 
     514    hdr = (pjsip_hdr*) pjsip_msg_find_hdr( invite_msg, PJSIP_H_ROUTE, NULL); 
    508515    while (hdr != NULL) { 
    509         pjsip_msg_add_hdr( ack->msg, pjsip_hdr_clone(ack->pool, hdr) ); 
     516        pjsip_msg_add_hdr( ack->msg,  
     517                           (pjsip_hdr*) pjsip_hdr_clone(ack->pool, hdr) ); 
    510518        hdr = hdr->next; 
    511519        if (hdr == &invite_msg->hdr) 
    512520            break; 
    513         hdr = pjsip_msg_find_hdr( invite_msg, PJSIP_H_ROUTE, hdr); 
     521        hdr = (pjsip_hdr*) pjsip_msg_find_hdr( invite_msg, PJSIP_H_ROUTE, hdr); 
    514522    } 
    515523 
     
    579587 
    580588    /* Clear Via headers in the new request. */ 
    581     while ((via=pjsip_msg_find_hdr(cancel_tdata->msg, PJSIP_H_VIA, NULL)) != NULL) 
     589    while ((via=(pjsip_hdr*)pjsip_msg_find_hdr(cancel_tdata->msg, PJSIP_H_VIA, NULL)) != NULL) 
    582590        pj_list_erase(via); 
    583591 
     
    586594     * request being cancelled.  
    587595     */ 
    588     hdr = pjsip_msg_find_hdr(req_tdata->msg, PJSIP_H_VIA, NULL); 
     596    hdr = (pjsip_hdr*) pjsip_msg_find_hdr(req_tdata->msg, PJSIP_H_VIA, NULL); 
    589597    if (hdr) { 
    590598        pjsip_msg_insert_first_hdr(cancel_tdata->msg,  
    591                                    pjsip_hdr_clone(cancel_tdata->pool, hdr)); 
     599                                   (pjsip_hdr*)pjsip_hdr_clone(cancel_tdata->pool, hdr)); 
    592600    } 
    593601 
     
    596604     * Copy "Route" header from the request. 
    597605     */ 
    598     hdr = pjsip_msg_find_hdr(req_tdata->msg, PJSIP_H_ROUTE, NULL); 
     606    hdr = (pjsip_hdr*) pjsip_msg_find_hdr(req_tdata->msg, PJSIP_H_ROUTE, NULL); 
    599607    while (hdr != NULL) { 
    600608        pjsip_msg_add_hdr(cancel_tdata->msg,  
    601                           pjsip_hdr_clone(cancel_tdata->pool, hdr)); 
     609                          (pjsip_hdr*) pjsip_hdr_clone(cancel_tdata->pool, hdr)); 
    602610        hdr = hdr->next; 
    603611        if (hdr != &req_tdata->msg->hdr) 
    604             hdr = pjsip_msg_find_hdr(req_tdata->msg, PJSIP_H_ROUTE, hdr); 
     612            hdr = (pjsip_hdr*) pjsip_msg_find_hdr(req_tdata->msg,  
     613                                                  PJSIP_H_ROUTE, hdr); 
    605614        else 
    606615            break; 
     
    638647    /* Get the first "Route" header from the message. 
    639648     */ 
    640     first_route_hdr = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_ROUTE, NULL); 
     649    first_route_hdr = (const pjsip_route_hdr*)  
     650                      pjsip_msg_find_hdr(tdata->msg, PJSIP_H_ROUTE, NULL); 
    641651    if (first_route_hdr) { 
    642652        target_uri = first_route_hdr->name_addr.uri; 
     
    698708 
    699709    /* Find the first and last "Route" headers from the message. */ 
    700     last_route_hdr = first_route_hdr =  
     710    last_route_hdr = first_route_hdr = (pjsip_route_hdr*) 
    701711        pjsip_msg_find_hdr(tdata->msg, PJSIP_H_ROUTE, NULL); 
    702712    if (first_route_hdr) { 
     
    704714        while (last_route_hdr->next != (void*)&tdata->msg->hdr) { 
    705715            pjsip_route_hdr *hdr; 
    706             hdr = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_ROUTE,  
     716            hdr = (pjsip_route_hdr*) 
     717                  pjsip_msg_find_hdr(tdata->msg, PJSIP_H_ROUTE,  
    707718                                     last_route_hdr->next); 
    708719            if (!hdr) 
     
    729740            PJSIP_URI_SCHEME_IS_SIPS(topmost_route_uri)) 
    730741        { 
    731             const pjsip_sip_uri *url =  
     742            const pjsip_sip_uri *url = (const pjsip_sip_uri*) 
    732743                pjsip_uri_get_uri((void*)topmost_route_uri); 
    733744            has_lr_param = url->lr_param; 
     
    748759            */ 
    749760        } else { 
    750             new_request_uri = pjsip_uri_get_uri((void*)topmost_route_uri); 
     761            new_request_uri = (const pjsip_uri*)  
     762                              pjsip_uri_get_uri((pjsip_uri*)topmost_route_uri); 
    751763            pj_list_erase(first_route_hdr); 
    752764            if (first_route_hdr == last_route_hdr) 
     
    794806    if (new_request_uri && new_request_uri!=tdata->msg->line.req.uri) { 
    795807        pjsip_route_hdr *route = pjsip_route_hdr_create(tdata->pool); 
    796         route->name_addr.uri = pjsip_uri_get_uri(tdata->msg->line.req.uri); 
     808        route->name_addr.uri = (pjsip_uri*)  
     809                               pjsip_uri_get_uri(tdata->msg->line.req.uri); 
    797810        if (last_route_hdr) 
    798811            pj_list_insert_after(last_route_hdr, route); 
     
    815828                                         pj_ssize_t sent ) 
    816829{ 
    817     pjsip_send_state *stateless_data = token; 
     830    pjsip_send_state *stateless_data = (pjsip_send_state*) token; 
    818831 
    819832    PJ_UNUSED_ARG(tdata); 
     
    916929        if (via->branch_param.slen == 0) { 
    917930            pj_str_t tmp; 
    918             via->branch_param.ptr = pj_pool_alloc(tdata->pool, 
    919                                                   PJSIP_MAX_BRANCH_LEN); 
     931            via->branch_param.ptr = (char*)pj_pool_alloc(tdata->pool, 
     932                                                         PJSIP_MAX_BRANCH_LEN); 
    920933            via->branch_param.slen = PJSIP_MAX_BRANCH_LEN; 
    921934            pj_memcpy(via->branch_param.ptr, PJSIP_RFC3261_BRANCH_ID, 
     
    961974                                  const struct pjsip_server_addresses *addr) 
    962975{ 
    963     pjsip_send_state *stateless_data = token; 
     976    pjsip_send_state *stateless_data = (pjsip_send_state*) token; 
    964977 
    965978    /* Fail on server resolution. */ 
     
    10091022 
    10101023    /* Keep stateless data. */ 
    1011     stateless_data = pj_pool_zalloc(tdata->pool, sizeof(pjsip_send_state)); 
     1024    stateless_data = PJ_POOL_ZALLOC_T(tdata->pool, pjsip_send_state); 
    10121025    stateless_data->token = token; 
    10131026    stateless_data->endpt = endpt; 
     
    11361149                                       pj_ssize_t sent) 
    11371150{ 
    1138     pjsip_send_state *send_state = token; 
     1151    pjsip_send_state *send_state = (pjsip_send_state*) token; 
    11391152    pj_bool_t cont = PJ_FALSE; 
    11401153 
     
    11561169                                       const pjsip_server_addresses *addr ) 
    11571170{ 
    1158     pjsip_send_state *send_state = token; 
     1171    pjsip_send_state *send_state = (pjsip_send_state*) token; 
    11591172 
    11601173    if (status != PJ_SUCCESS) { 
     
    12251238 
    12261239    /* Create structure to keep the sending state. */ 
    1227     send_state = pj_pool_zalloc(tdata->pool, sizeof(pjsip_send_state)); 
     1240    send_state = PJ_POOL_ZALLOC_T(tdata->pool, pjsip_send_state); 
    12281241    send_state->endpt = endpt; 
    12291242    send_state->tdata = tdata; 
     
    13181331        const pjsip_hdr *hdr = hdr_list->next; 
    13191332        while (hdr != hdr_list) { 
    1320             pjsip_msg_add_hdr( tdata->msg, pjsip_hdr_clone(tdata->pool, hdr) ); 
     1333            pjsip_msg_add_hdr(tdata->msg,  
     1334                              (pjsip_hdr*) pjsip_hdr_clone(tdata->pool, hdr) ); 
    13211335            hdr = hdr->next; 
    13221336        } 
  • pjproject/trunk/pjsip/src/pjsip/sip_util_proxy.c

    r1127 r1241  
    129129        /* Set request URI */ 
    130130        if (uri) { 
    131             dst->line.req.uri = pjsip_uri_clone(tdata->pool, uri); 
     131            dst->line.req.uri = (pjsip_uri*)  
     132                                pjsip_uri_clone(tdata->pool, uri); 
    132133        } else { 
    133             dst->line.req.uri = pjsip_uri_clone(tdata->pool, src->line.req.uri); 
     134            dst->line.req.uri= (pjsip_uri*) 
     135                               pjsip_uri_clone(tdata->pool, src->line.req.uri); 
    134136        } 
    135137 
     
    193195 
    194196            /* Clone the header */ 
    195             hdst = pjsip_hdr_clone(tdata->pool, hsrc); 
     197            hdst = (pjsip_hdr*) pjsip_hdr_clone(tdata->pool, hsrc); 
    196198 
    197199            /* If this is Max-Forward header, decrement the value */ 
     
    292294            } 
    293295 
    294             pjsip_msg_add_hdr(dst, pjsip_hdr_clone(tdata->pool, hsrc)); 
     296            pjsip_msg_add_hdr(dst,  
     297                              (pjsip_hdr*)pjsip_hdr_clone(tdata->pool, hsrc)); 
    295298 
    296299            hsrc = hsrc->next; 
     
    342345    pj_md5_final(&ctx, digest); 
    343346 
    344     branch.ptr = pj_pool_alloc(rdata->tp_info.pool,  
     347    branch.ptr = (char*) 
     348                 pj_pool_alloc(rdata->tp_info.pool,  
    345349                               32 + PJSIP_RFC3261_BRANCH_LEN); 
    346350    pj_memcpy(branch.ptr, PJSIP_RFC3261_BRANCH_ID, PJSIP_RFC3261_BRANCH_LEN); 
  • pjproject/trunk/pjsip/src/pjsip/sip_util_statefull.c

    r1210 r1241  
    6262        return; 
    6363 
    64     tsx_data = tsx->mod_data[mod_stateful_util.id]; 
     64    tsx_data = (struct tsx_data*) tsx->mod_data[mod_stateful_util.id]; 
    6565    if (tsx_data == NULL) 
    6666        return; 
     
    103103    } 
    104104 
    105     tsx_data = pj_pool_alloc(tsx->pool, sizeof(struct tsx_data)); 
     105    tsx_data = PJ_POOL_ALLOC_T(tsx->pool, struct tsx_data); 
    106106    tsx_data->token = token; 
    107107    tsx_data->cb = cb; 
     
    148148        const pjsip_hdr *hdr = hdr_list->next; 
    149149        while (hdr != hdr_list) { 
    150             pjsip_msg_add_hdr( tdata->msg, pjsip_hdr_clone(tdata->pool, hdr) ); 
     150            pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*) 
     151                              pjsip_hdr_clone(tdata->pool, hdr) ); 
    151152            hdr = hdr->next; 
    152153        } 
Note: See TracChangeset for help on using the changeset viewer.