Changeset 2387


Ignore:
Timestamp:
Dec 19, 2008 12:26:42 PM (13 years ago)
Author:
bennylp
Message:

Fixed ticket #686: Failure to cancel outstanding DNS SRV query job (API change)

Location:
pjproject/trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • pjproject/trunk/pjlib-util/include/pjlib-util/srv_resolver.h

    r2039 r2387  
    137137} pj_dns_srv_record; 
    138138 
     139 
     140/** Opaque declaration for DNS SRV query */ 
     141typedef struct pj_dns_srv_async_query pj_dns_srv_async_query; 
    139142 
    140143/** 
     
    185188                                        void *token, 
    186189                                        pj_dns_srv_resolver_cb *cb, 
    187                                         pj_dns_async_query **p_query); 
     190                                        pj_dns_srv_async_query **p_query); 
     191 
     192 
     193/** 
     194 * Cancel an outstanding DNS SRV query. 
     195 * 
     196 * @param query     The pending asynchronous query to be cancelled. 
     197 * @param notify    If non-zero, the callback will be called with failure 
     198 *                  status to notify that the query has been cancelled. 
     199 * 
     200 * @return          PJ_SUCCESS on success, or the appropriate error code, 
     201 */ 
     202PJ_DECL(pj_status_t) pj_dns_srv_cancel_query(pj_dns_srv_async_query *query, 
     203                                             pj_bool_t notify); 
    188204 
    189205 
  • pjproject/trunk/pjlib-util/src/pjlib-util/srv_resolver.c

    r2039 r2387  
    2222#include <pj/assert.h> 
    2323#include <pj/log.h> 
     24#include <pj/os.h> 
    2425#include <pj/pool.h> 
    2526#include <pj/rand.h> 
     
    3132#define ADDR_MAX_COUNT      PJ_DNS_MAX_IP_IN_A_REC 
    3233 
     34struct common 
     35{ 
     36    pj_dns_type              type;          /**< Type of this structure.*/ 
     37}; 
     38 
    3339struct srv_target 
    3440{ 
     41    struct common           common; 
     42    pj_dns_srv_async_query *parent; 
    3543    pj_str_t                target_name; 
     44    pj_dns_async_query     *q_a; 
    3645    char                    target_buf[PJ_MAX_HOSTNAME]; 
    3746    pj_str_t                cname; 
     
    4554}; 
    4655 
    47 typedef struct pj_dns_srv_resolver_job 
    48 { 
     56struct pj_dns_srv_async_query 
     57{ 
     58    struct common            common; 
    4959    char                    *objname; 
    5060 
     61    pj_dns_type              dns_state;     /**< DNS type being resolved.   */ 
    5162    pj_dns_resolver         *resolver;      /**< Resolver SIP instance.     */ 
    52     pj_dns_type              dns_state;     /**< DNS type being resolved.   */ 
    5363    void                    *token; 
     64    pj_dns_async_query      *q_srv; 
    5465    pj_dns_srv_resolver_cb  *cb; 
    5566    pj_status_t              last_error; 
     
    6879    unsigned                 host_resolved; 
    6980 
    70 } pj_dns_srv_resolver_job; 
     81}; 
    7182 
    7283 
     
    89100                                        void *token, 
    90101                                        pj_dns_srv_resolver_cb *cb, 
    91                                         pj_dns_async_query **p_query) 
     102                                        pj_dns_srv_async_query **p_query) 
    92103{ 
    93104    int len; 
    94105    pj_str_t target_name; 
    95     pj_dns_srv_resolver_job *query_job; 
     106    pj_dns_srv_async_query *query_job; 
    96107    pj_status_t status; 
    97108 
     
    112123 
    113124    /* Build the query_job state */ 
    114     query_job = PJ_POOL_ZALLOC_T(pool, pj_dns_srv_resolver_job); 
     125    query_job = PJ_POOL_ZALLOC_T(pool, pj_dns_srv_async_query); 
     126    query_job->common.type = PJ_DNS_TYPE_SRV; 
    115127    query_job->objname = target_name.ptr; 
    116128    query_job->resolver = resolver; 
     
    136148                                         query_job->dns_state, 0,  
    137149                                         &dns_callback, 
    138                                          query_job, p_query); 
     150                                         query_job, &query_job->q_srv); 
     151    if (status==PJ_SUCCESS && p_query) 
     152        *p_query = query_job; 
     153 
    139154    return status; 
    140155} 
    141156 
     157 
     158/* 
     159 * Cancel pending query. 
     160 */ 
     161PJ_DEF(pj_status_t) pj_dns_srv_cancel_query(pj_dns_srv_async_query *query, 
     162                                            pj_bool_t notify) 
     163{ 
     164    pj_bool_t has_pending = PJ_FALSE; 
     165    unsigned i; 
     166 
     167    if (query->q_srv) { 
     168        pj_dns_resolver_cancel_query(query->q_srv, PJ_FALSE); 
     169        query->q_srv = NULL; 
     170        has_pending = PJ_TRUE; 
     171    } 
     172 
     173    for (i=0; i<query->srv_cnt; ++i) { 
     174        struct srv_target *srv = &query->srv[i]; 
     175        if (srv->q_a) { 
     176            pj_dns_resolver_cancel_query(srv->q_a, PJ_FALSE); 
     177            srv->q_a = NULL; 
     178            has_pending = PJ_TRUE; 
     179        } 
     180    } 
     181 
     182    if (has_pending && notify && query->cb) { 
     183        (*query->cb)(query->token, PJ_ECANCELLED, NULL); 
     184    } 
     185 
     186    return has_pending? PJ_SUCCESS : PJ_EINVALIDOP; 
     187} 
    142188 
    143189 
     
    153199 
    154200/* Build server entries in the query_job based on received SRV response */ 
    155 static void build_server_entries(pj_dns_srv_resolver_job *query_job,  
     201static void build_server_entries(pj_dns_srv_async_query *query_job,  
    156202                                 pj_dns_parsed_packet *response) 
    157203{ 
     
    357403 
    358404/* Start DNS A record queries for all SRV records in the query_job structure */ 
    359 static pj_status_t resolve_hostnames(pj_dns_srv_resolver_job *query_job) 
     405static pj_status_t resolve_hostnames(pj_dns_srv_async_query *query_job) 
    360406{ 
    361407    unsigned i; 
     
    364410    query_job->dns_state = PJ_DNS_TYPE_A; 
    365411    for (i=0; i<query_job->srv_cnt; ++i) { 
     412        struct srv_target *srv = &query_job->srv[i]; 
     413 
    366414        PJ_LOG(5, (query_job->objname,  
    367415                   "Starting async DNS A query_job for %.*s", 
    368                    (int)query_job->srv[i].target_name.slen,  
    369                    query_job->srv[i].target_name.ptr)); 
     416                   (int)srv->target_name.slen,  
     417                   srv->target_name.ptr)); 
     418 
     419        srv->common.type = PJ_DNS_TYPE_A; 
     420        srv->parent = query_job; 
    370421 
    371422        status = pj_dns_resolver_start_query(query_job->resolver, 
    372                                              &query_job->srv[i].target_name, 
     423                                             &srv->target_name, 
    373424                                             PJ_DNS_TYPE_A, 0, 
    374425                                             &dns_callback, 
    375                                              query_job, NULL); 
     426                                             srv, &srv->q_a); 
    376427        if (status != PJ_SUCCESS) { 
    377428            query_job->host_resolved++; 
     
    391442                         pj_dns_parsed_packet *pkt) 
    392443{ 
    393     pj_dns_srv_resolver_job *query_job = (pj_dns_srv_resolver_job*) user_data; 
     444    struct common *common = (struct common*) user_data; 
     445    pj_dns_srv_async_query *query_job; 
     446    struct srv_target *srv = NULL; 
    394447    unsigned i; 
    395448 
     449    if (common->type == PJ_DNS_TYPE_SRV) { 
     450        query_job = (pj_dns_srv_async_query*) common; 
     451        srv = NULL; 
     452    } else if (common->type == PJ_DNS_TYPE_A) { 
     453        srv = (struct srv_target*) common; 
     454        query_job = srv->parent; 
     455    } else { 
     456        pj_assert(!"Unexpected user data!"); 
     457        query_job->last_error = status = PJ_EINVALIDOP; 
     458        goto on_error; 
     459    } 
     460 
    396461    /* Proceed to next stage */ 
    397  
    398462    if (query_job->dns_state == PJ_DNS_TYPE_SRV) { 
    399463 
    400464        /* We are getting SRV response */ 
     465 
     466        query_job->q_srv = NULL; 
    401467 
    402468        if (status == PJ_SUCCESS && pkt->hdr.anscount != 0) { 
     
    469535    } else if (query_job->dns_state == PJ_DNS_TYPE_A) { 
    470536 
     537        /* Clear the outstanding job */ 
     538        srv->q_a = NULL; 
     539 
    471540        /* Check that we really have answer */ 
    472541        if (status==PJ_SUCCESS && pkt->hdr.anscount != 0) { 
    473             unsigned srv_idx; 
    474             struct srv_target *srv = NULL; 
    475542            pj_dns_a_record rec; 
    476543 
     
    481548 
    482549            pj_assert(rec.addr_count != 0); 
    483  
    484             /* Find which server entry to be updated. */ 
    485             for (srv_idx=0; srv_idx<query_job->srv_cnt; ++srv_idx) { 
    486                 srv = &query_job->srv[srv_idx]; 
    487                 if (pj_stricmp(&rec.name, &srv->target_name)==0) { 
    488                     break; 
    489                 } 
    490             } 
    491  
    492             if (srv_idx==query_job->srv_cnt) { 
    493                 /* The DNS A response doesn't match any server names 
    494                  * we're querying! 
    495                  */ 
    496                 status = PJLIB_UTIL_EDNSINANSWER; 
    497                 goto on_error; 
    498             } 
    499  
    500             srv = &query_job->srv[srv_idx]; 
    501550 
    502551            /* Update CNAME alias, if present. */ 
  • pjproject/trunk/pjnath/src/pjnath/stun_sock.c

    r2383 r2387  
    4848    pj_sockaddr          mapped_addr;   /* Our public address       */ 
    4949 
    50     pj_dns_async_query  *q;             /* Pending DNS query        */ 
     50    pj_dns_srv_async_query *q;          /* Pending DNS query        */ 
    5151    pj_sock_t            sock_fd;       /* Socket descriptor        */ 
    5252    pj_activesock_t     *active_sock;   /* Active socket object     */ 
     
    371371{ 
    372372    if (stun_sock->q) { 
    373         pj_dns_resolver_cancel_query(stun_sock->q, PJ_FALSE); 
     373        pj_dns_srv_cancel_query(stun_sock->q, PJ_FALSE); 
    374374        stun_sock->q = NULL; 
    375375    } 
  • pjproject/trunk/pjnath/src/pjnath/turn_session.c

    r2386 r2387  
    8787    pj_timer_entry       timer; 
    8888 
    89     pj_dns_async_query  *dns_async; 
     89    pj_dns_srv_async_query *dns_async; 
    9090    pj_uint16_t          default_port; 
    9191 
     
    343343    case PJ_TURN_STATE_RESOLVING: 
    344344        if (sess->dns_async != NULL) { 
    345             pj_dns_resolver_cancel_query(sess->dns_async, PJ_FALSE); 
     345            pj_dns_srv_cancel_query(sess->dns_async, PJ_FALSE); 
    346346            sess->dns_async = NULL; 
    347347        } 
Note: See TracChangeset for help on using the changeset viewer.