自学教程：C++ Curl_share_unlock函数代码示例

/* * Curl_resolv_unlock() unlocks the given cached DNS entry. When this has been * made, the struct may be destroyed due to pruning. It is important that only * one unlock is made for each Curl_resolv() call. * * May be called with 'data' == NULL for global cache. */void Curl_resolv_unlock(struct Curl_easy *data, struct Curl_dns_entry *dns){  if(data && data->share)    Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);  freednsentry(dns);  if(data && data->share)    Curl_share_unlock(data, CURL_LOCK_DATA_DNS);}

void Curl_hostcache_clean(struct SessionHandle *data,                          struct curl_hash *hash){  if(data && data->share)    Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);  Curl_hash_clean(hash);  if(data && data->share)    Curl_share_unlock(data, CURL_LOCK_DATA_DNS);}

/* * Curl_resolv_unlock() unlocks the given cached DNS entry. When this has been * made, the struct may be destroyed due to pruning. It is important that only * one unlock is made for each Curl_resolv() call. */void Curl_resolv_unlock(struct SessionHandle *data, struct Curl_dns_entry *dns){  curlassert(dns && (dns->inuse>0));  if(data->share)    Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);  dns->inuse--;  if(data->share)    Curl_share_unlock(data, CURL_LOCK_DATA_DNS);}

/* * addrinfo_callback() gets called by ares, gethostbyname_thread() or * getaddrinfo_thread() when we got the name resolved (or not!). * * If the status argument is CURL_ASYNC_SUCCESS, we might need to copy the * address field since it might be freed when this function returns. This * operation stores the resolved data in the DNS cache. * * NOTE: for IPv6 operations, Curl_addrinfo_copy() returns the same * pointer it is given as argument! * * The storage operation locks and unlocks the DNS cache. */static CURLcode addrinfo_callback(void *arg, /* "struct connectdata *" */                                  int status,                                  void *addr){  struct connectdata *conn = (struct connectdata *)arg;  struct Curl_dns_entry *dns = NULL;  CURLcode rc = CURLE_OK;  conn->async.status = status;  if(CURL_ASYNC_SUCCESS == status) {    /*     * IPv4/ares: Curl_addrinfo_copy() copies the address and returns an     * allocated version.     *     * IPv6: Curl_addrinfo_copy() returns the input pointer!     */    Curl_addrinfo *ai = Curl_addrinfo_copy(addr, conn->async.port);    if(ai) {      struct SessionHandle *data = conn->data;      if(data->share)        Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);      dns = Curl_cache_addr(data, ai,                            conn->async.hostname,                            conn->async.port);      if(!dns) {        /* failed to store, cleanup and return error */        Curl_freeaddrinfo(ai);        rc = CURLE_OUT_OF_MEMORY;      }      if(data->share)        Curl_share_unlock(data, CURL_LOCK_DATA_DNS);    }    else      rc = CURLE_OUT_OF_MEMORY;  }  conn->async.dns = dns; /* Set async.done TRUE last in this function since it may be used multi-    threaded and once this is TRUE the other thread may read fields from the    async struct */  conn->async.done = TRUE;  /* ipv4: The input hostent struct will be freed by ares when we return from     this function */  return rc;}

/* * Check if there's a session ID for the given connection in the cache, and if * there's one suitable, it is provided. Returns TRUE when no entry matched. */int Curl_ssl_getsessionid(struct connectdata *conn,                          void **ssl_sessionid,                          size_t *idsize) /* set 0 if unknown */{    struct curl_ssl_session *check;    struct SessionHandle *data = conn->data;    size_t i;    long *general_age;    bool no_match = TRUE;    *ssl_sessionid = NULL;    if(!conn->ssl_config.sessionid)        /* session ID re-use is disabled */        return TRUE;    /* Lock if shared */    if(SSLSESSION_SHARED(data)) {        Curl_share_lock(data, CURL_LOCK_DATA_SSL_SESSION, CURL_LOCK_ACCESS_SINGLE);        general_age = &data->share->sessionage;    }    else        general_age = &data->state.sessionage;    for(i = 0; i < data->set.ssl.max_ssl_sessions; i++) {        check = &data->state.session[i];        if(!check->sessionid)            /* not session ID means blank entry */            continue;        if(Curl_raw_equal(conn->host.name, check->name) &&                (conn->remote_port == check->remote_port) &&                Curl_ssl_config_matches(&conn->ssl_config, &check->ssl_config)) {            /* yes, we have a session ID! */            (*general_age)++;          /* increase general age */            check->age = *general_age; /* set this as used in this age */            *ssl_sessionid = check->sessionid;            if(idsize)                *idsize = check->idsize;            no_match = FALSE;            break;        }    }    /* Unlock */    if(SSLSESSION_SHARED(data))        Curl_share_unlock(data, CURL_LOCK_DATA_SSL_SESSION);    return no_match;}

void Curl_resolv_unlock(struct SessionHandle *data, struct Curl_dns_entry *dns){  if(data->share)    Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);  dns->inuse--;#ifdef CURLDEBUG  if(dns->inuse < 0) {    infof(data, "Interal host cache screw-up!");    *(char **)0=NULL;  }#endif  if(data->share)    Curl_share_unlock(data, CURL_LOCK_DATA_DNS);}

/* * Load cookies from all given cookie files (CURLOPT_COOKIEFILE). */void Curl_cookie_loadfiles(struct SessionHandle *data){  struct curl_slist *list = data->change.cookielist;  if(list) {    Curl_share_lock(data, CURL_LOCK_DATA_COOKIE, CURL_LOCK_ACCESS_SINGLE);    while(list) {      data->cookies = Curl_cookie_init(data,                                       list->data,                                       data->cookies,                                       data->set.cookiesession);      list = list->next;    }    curl_slist_free_all(data->change.cookielist); /* clean up list */    data->change.cookielist = NULL; /* don't do this again! */    Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE);  }}

/* * Curl_resolv_unlock() unlocks the given cached DNS entry. When this has been * made, the struct may be destroyed due to pruning. It is important that only * one unlock is made for each Curl_resolv() call. */void Curl_resolv_unlock(struct SessionHandle *data, struct Curl_dns_entry *dns){  DEBUGASSERT(dns && (dns->inuse>0));  if(data->share)    Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);  dns->inuse--;  /* only free if nobody is using AND it is not in hostcache (timestamp ==     0) */  if (dns->inuse == 0 && dns->timestamp == 0) {    Curl_freeaddrinfo(dns->addr);    free(dns);  }  if(data->share)    Curl_share_unlock(data, CURL_LOCK_DATA_DNS);}

/* * Curl_addrinfo_callback() gets called by ares, gethostbyname_thread() * or getaddrinfo_thread() when we got the name resolved (or not!). * * If the status argument is CURL_ASYNC_SUCCESS, this function takes * ownership of the Curl_addrinfo passed, storing the resolved data * in the DNS cache. * * The storage operation locks and unlocks the DNS cache. */CURLcode Curl_addrinfo_callback(struct connectdata *conn,                                int status,                                struct Curl_addrinfo *ai){    struct Curl_dns_entry *dns = NULL;    CURLcode result = CURLE_OK;    conn->async.status = status;    if(CURL_ASYNC_SUCCESS == status) {        if(ai) {            struct SessionHandle *data = conn->data;            if(data->share)                Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);            dns = Curl_cache_addr(data, ai,                                  conn->async.hostname,                                  conn->async.port);            if(!dns) {                /* failed to store, cleanup and return error */                Curl_freeaddrinfo(ai);                result = CURLE_OUT_OF_MEMORY;            }            if(data->share)                Curl_share_unlock(data, CURL_LOCK_DATA_DNS);        }        else {            result = CURLE_OUT_OF_MEMORY;        }    }    conn->async.dns = dns;    /* Set async.done TRUE last in this function since it may be used multi-       threaded and once this is TRUE the other thread may read fields from the       async struct */    conn->async.done = TRUE;    /* IPv4: The input hostent struct will be freed by ares when we return from       this function */    return result;}

/* * Check if there's a session ID for the given connection in the cache, and if * there's one suitable, it is provided. Returns TRUE when no entry matched. */int Curl_ssl_getsessionid(struct connectdata *conn,                          void **ssl_sessionid,                          size_t *idsize) /* set 0 if unknown */{  struct curl_ssl_session *check;  struct SessionHandle *data = conn->data;  long i;  if(!conn->ssl_config.sessionid)    /* session ID re-use is disabled */    return TRUE;  /* Lock for reading if shared */  if(data->share && data->share->sslsession == data->state.session)    Curl_share_lock(data, CURL_LOCK_DATA_SSL_SESSION, CURL_LOCK_ACCESS_SHARED);  for(i=0; i< data->set.ssl.numsessions; i++) {    check = &data->state.session[i];    if(!check->sessionid)      /* not session ID means blank entry */      continue;    if(Curl_raw_equal(conn->host.name, check->name) &&       (conn->remote_port == check->remote_port) &&       Curl_ssl_config_matches(&conn->ssl_config, &check->ssl_config)) {      /* yes, we have a session ID! */      data->state.sessionage++;            /* increase general age */      check->age = data->state.sessionage; /* set this as used in this age */      *ssl_sessionid = check->sessionid;      if(idsize)        *idsize = check->idsize;      return FALSE;    }  }  *ssl_sessionid = NULL;  /* Unlock for reading */  if(data->share && data->share->sslsession == data->state.session)    Curl_share_unlock(data, CURL_LOCK_DATA_SSL_SESSION);  return TRUE;}

/* * Curl_fetch_addr() fetches a 'Curl_dns_entry' already in the DNS cache. * * Curl_resolv() checks initially and multi_runsingle() checks each time * it discovers the handle in the state WAITRESOLVE whether the hostname * has already been resolved and the address has already been stored in * the DNS cache. This short circuits waiting for a lot of pending * lookups for the same hostname requested by different handles. * * Returns the Curl_dns_entry entry pointer or NULL if not in the cache. * * The returned data *MUST* be "unlocked" with Curl_resolv_unlock() after * use, or we'll leak memory! */struct Curl_dns_entry *Curl_fetch_addr(struct connectdata *conn,                const char *hostname,                int port){  struct SessionHandle *data = conn->data;  struct Curl_dns_entry *dns = NULL;  if(data->share)    Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);  dns = fetch_addr(conn, hostname, port);  if(dns) dns->inuse++; /* we use it! */  if(data->share)    Curl_share_unlock(data, CURL_LOCK_DATA_DNS);  return dns;}

/* * Delete the given session ID from the cache. */void Curl_ssl_delsessionid(struct connectdata *conn, void *ssl_sessionid){    size_t i;    struct SessionHandle *data=conn->data;    if(SSLSESSION_SHARED(data))        Curl_share_lock(data, CURL_LOCK_DATA_SSL_SESSION, CURL_LOCK_ACCESS_SINGLE);    for(i = 0; i < data->set.ssl.max_ssl_sessions; i++) {        struct curl_ssl_session *check = &data->state.session[i];        if(check->sessionid == ssl_sessionid) {            Curl_ssl_kill_session(check);            break;        }    }    if(SSLSESSION_SHARED(data))        Curl_share_unlock(data, CURL_LOCK_DATA_SSL_SESSION);}

void Curl_hostcache_prune(struct SessionHandle *data){  time_t now;  if(data->set.dns_cache_timeout == -1)    /* cache forever means never prune! */    return;  if(data->share)    Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);  time(&now);  /* Remove outdated and unused entries from the hostcache */  hostcache_prune(data->hostcache,                  data->set.dns_cache_timeout,                  now);  if(data->share)    Curl_share_unlock(data, CURL_LOCK_DATA_DNS);}

void Curl_ssl_close_all(struct SessionHandle *data){  long i;  /* kill the session ID cache */  if(data->state.session &&     !(data->share && data->share->sslsession == data->state.session)) {    Curl_share_lock(data, CURL_LOCK_DATA_SSL_SESSION, CURL_LOCK_ACCESS_SINGLE);    for(i=0; i< data->set.ssl.numsessions; i++)      /* the single-killer function handles empty table slots */      Curl_ssl_kill_session(&data->state.session[i]);    /* free the cache data */    free(data->state.session);    data->state.session = NULL;    Curl_share_unlock(data, CURL_LOCK_DATA_SSL_SESSION);  }  curlssl_close_all(data);}

/* * Library-wide function for pruning the DNS cache. This function takes and * returns the appropriate locks. */void Curl_hostcache_prune(struct Curl_easy *data){  time_t now;  if((data->set.dns_cache_timeout == -1) || !data->dns.hostcache)    /* cache forever means never prune, and NULL hostcache means       we can't do it */    return;  if(data->share)    Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);  time(&now);  /* Remove outdated and unused entries from the hostcache */  hostcache_prune(data->dns.hostcache,                  data->set.dns_cache_timeout,                  now);  if(data->share)    Curl_share_unlock(data, CURL_LOCK_DATA_DNS);}

/* this function gets called by ares/gethostbyname_thread() when we got   the name resolved or not */static void host_callback(void *arg, /* "struct connectdata *" */                          int status,                          struct hostent *hostent){  struct connectdata *conn = (struct connectdata *)arg;  struct Curl_dns_entry *dns = NULL;  conn->async.done = TRUE;  conn->async.status = status;  if(ARES_SUCCESS == status) {    /* we got a resolved name in 'hostent' */    char *bufp = (char *)malloc(CURL_NAMELOOKUP_SIZE);    if(bufp) {      /* pack_hostent() copies to and shrinks the target buffer */      struct hostent *he = pack_hostent(&bufp, hostent);      struct SessionHandle *data = conn->data;      if(data->share)        Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);      dns = cache_resolv_response(data, he,                                  conn->async.hostname, conn->async.port);      if(data->share)        Curl_share_unlock(data, CURL_LOCK_DATA_DNS);    }  }  conn->async.dns = dns;  /* The input hostent struct will be freed by ares when we return from this     function */}

/* * Load cookies from all given cookie files (CURLOPT_COOKIEFILE). * * NOTE: OOM or cookie parsing failures are ignored. */void Curl_cookie_loadfiles(struct Curl_easy *data){  struct curl_slist *list = data->change.cookielist;  if(list) {    Curl_share_lock(data, CURL_LOCK_DATA_COOKIE, CURL_LOCK_ACCESS_SINGLE);    while(list) {      struct CookieInfo *newcookies = Curl_cookie_init(data,                                        list->data,                                        data->cookies,                                        data->set.cookiesession);      if(!newcookies)        /* Failure may be due to OOM or a bad cookie; both are ignored         * but only the first should be         */        infof(data, "ignoring failed cookie_init for %s/n", list->data);      else        data->cookies = newcookies;      list = list->next;    }    curl_slist_free_all(data->change.cookielist); /* clean up list */    data->change.cookielist = NULL; /* don't do this again! */    Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE);  }}

/* Resolve a name and return a pointer in the 'entry' argument if one   is available.   Return codes:   -1 = error, no pointer   0 = OK, pointer provided   1 = waiting for response, no pointer*/int Curl_resolv(struct connectdata *conn,                char *hostname,                int port,                struct Curl_dns_entry **entry){  char *entry_id = NULL;  struct Curl_dns_entry *dns = NULL;  size_t entry_len;  int wait;  struct SessionHandle *data = conn->data;  CURLcode result;  /* default to failure */  int rc = -1;  *entry = NULL;#ifdef HAVE_SIGSETJMP  /* this allows us to time-out from the name resolver, as the timeout     will generate a signal and we will siglongjmp() from that here */  if(!data->set.no_signal && sigsetjmp(curl_jmpenv, 1)) {    /* this is coming from a siglongjmp() */    failf(data, "name lookup timed out");    return -1;  }#endif  /* Create an entry id, based upon the hostname and port */  entry_id = create_hostcache_id(hostname, port, &entry_len);  /* If we can't create the entry id, fail */  if (!entry_id)    return -1;  if(data->share)    Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);  /* See if its already in our dns cache */  dns = Curl_hash_pick(data->hostcache, entry_id, entry_len+1);    if(data->share)    Curl_share_unlock(data, CURL_LOCK_DATA_DNS);  /* free the allocated entry_id again */  free(entry_id);  if (!dns) {    /* The entry was not in the cache. Resolve it to IP address */          /* If my_getaddrinfo() returns NULL, 'wait' might be set to a non-zero       value indicating that we need to wait for the response to the resolve       call */    Curl_addrinfo *addr = my_getaddrinfo(conn, hostname, port, &wait);        if (!addr) {      if(wait) {        /* the response to our resolve call will come asynchronously at            a later time, good or bad */        /* First, check that we haven't received the info by now */        result = Curl_is_resolved(conn, &dns);        if(result) /* error detected */          return -1;        if(dns)          rc = 0; /* pointer provided */        else          rc = 1; /* no info yet */      }    }    else {      if(data->share)        Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);      /* we got a response, store it in the cache */      dns = cache_resolv_response(data, addr, hostname, port);            if(data->share)        Curl_share_unlock(data, CURL_LOCK_DATA_DNS);      if(!dns)        /* returned failure, bail out nicely */        Curl_freeaddrinfo(addr);      else        rc = 0;    }  }  else {    dns->inuse++; /* we use it! */    rc = 0;  }  *entry = dns;  return rc;//.........这里部分代码省略.........

CURLcode Curl_doh_is_resolved(struct connectdata *conn,                              struct Curl_dns_entry **dnsp){  struct Curl_easy *data = conn->data;  *dnsp = NULL; /* defaults to no response */  if(!data->req.doh.probe[0].easy && !data->req.doh.probe[1].easy) {    failf(data, "Could not DOH-resolve: %s", conn->async.hostname);    return conn->bits.proxy?CURLE_COULDNT_RESOLVE_PROXY:      CURLE_COULDNT_RESOLVE_HOST;  }  else if(!data->req.doh.pending) {    DOHcode rc;    DOHcode rc2;    struct dohentry de;    struct Curl_dns_entry *dns;    struct Curl_addrinfo *ai;    /* remove DOH handles from multi handle and close them */    curl_multi_remove_handle(data->multi, data->req.doh.probe[0].easy);    Curl_close(data->req.doh.probe[0].easy);    curl_multi_remove_handle(data->multi, data->req.doh.probe[1].easy);    Curl_close(data->req.doh.probe[1].easy);    /* parse the responses, create the struct and return it! */    init_dohentry(&de);    rc = doh_decode(data->req.doh.probe[0].serverdoh.memory,                    data->req.doh.probe[0].serverdoh.size,                    data->req.doh.probe[0].dnstype,                    &de);    free(data->req.doh.probe[0].serverdoh.memory);    if(rc) {      infof(data, "DOH: %s type %s for %s/n", doh_strerror(rc),            type2name(data->req.doh.probe[0].dnstype),            data->req.doh.host);    }    rc2 = doh_decode(data->req.doh.probe[1].serverdoh.memory,                     data->req.doh.probe[1].serverdoh.size,                     data->req.doh.probe[1].dnstype,                     &de);    free(data->req.doh.probe[1].serverdoh.memory);    if(rc2) {      infof(data, "DOH: %s type %s for %s/n", doh_strerror(rc2),            type2name(data->req.doh.probe[1].dnstype),            data->req.doh.host);    }    if(!rc || !rc2) {      infof(data, "DOH Host name: %s/n", data->req.doh.host);      showdoh(data, &de);      ai = doh2ai(&de, data->req.doh.host, data->req.doh.port);      if(!ai) {        de_cleanup(&de);        return CURLE_OUT_OF_MEMORY;      }      if(data->share)        Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);      /* we got a response, store it in the cache */      dns = Curl_cache_addr(data, ai, data->req.doh.host, data->req.doh.port);      if(data->share)        Curl_share_unlock(data, CURL_LOCK_DATA_DNS);      de_cleanup(&de);      if(!dns)        /* returned failure, bail out nicely */        Curl_freeaddrinfo(ai);      else {        conn->async.dns = dns;        *dnsp = dns;        return CURLE_OK;      }    }    de_cleanup(&de);    return CURLE_COULDNT_RESOLVE_HOST;  }  return CURLE_OK;}

CURLcode Curl_loadhostpairs(struct SessionHandle *data){  struct curl_slist *hostp;  char hostname[256];  char address[256];  int port;  for(hostp = data->change.resolve; hostp; hostp = hostp->next ) {    if(!hostp->data)      continue;    if(hostp->data[0] == '-') {      /* TODO: mark an entry for removal */    }    else if(3 == sscanf(hostp->data, "%255[^:]:%d:%255s", hostname, &port,                        address)) {      struct Curl_dns_entry *dns;      Curl_addrinfo *addr;      char *entry_id;      size_t entry_len;      addr = Curl_str2addr(address, port);      if(!addr) {        infof(data, "Resolve %s found illegal!/n", hostp->data);        continue;      }      /* Create an entry id, based upon the hostname and port */      entry_id = create_hostcache_id(hostname, port);      /* If we can't create the entry id, fail */      if(!entry_id) {        Curl_freeaddrinfo(addr);        return CURLE_OUT_OF_MEMORY;      }      entry_len = strlen(entry_id);      if(data->share)        Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);      /* See if its already in our dns cache */      dns = Curl_hash_pick(data->dns.hostcache, entry_id, entry_len+1);      /* free the allocated entry_id again */      free(entry_id);      if(!dns)        /* if not in the cache already, put this host in the cache */        dns = Curl_cache_addr(data, addr, hostname, port);      else        /* this is a duplicate, free it again */        Curl_freeaddrinfo(addr);      if(data->share)        Curl_share_unlock(data, CURL_LOCK_DATA_DNS);      if(!dns) {        Curl_freeaddrinfo(addr);        return CURLE_OUT_OF_MEMORY;      }      infof(data, "Added %s:%d:%s to DNS cache/n",            hostname, port, address);    }  }  data->change.resolve = NULL; /* dealt with now */  return CURLE_OK;}

int Curl_resolv(struct connectdata *conn,                const char *hostname,                int port,                struct Curl_dns_entry **entry){  char *entry_id = NULL;  struct Curl_dns_entry *dns = NULL;  size_t entry_len;  struct SessionHandle *data = conn->data;  CURLcode result;  int rc = CURLRESOLV_ERROR; /* default to failure */  *entry = NULL;  /* Create an entry id, based upon the hostname and port */  entry_id = create_hostcache_id(hostname, port);  /* If we can't create the entry id, fail */  if(!entry_id)    return rc;  entry_len = strlen(entry_id);  if(data->share)    Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);  /* See if its already in our dns cache */  dns = Curl_hash_pick(data->dns.hostcache, entry_id, entry_len+1);  /* free the allocated entry_id again */  free(entry_id);  /* See whether the returned entry is stale. Done before we release lock */  if( remove_entry_if_stale(data, dns) )    dns = NULL; /* the memory deallocation is being handled by the hash */  if(dns) {    dns->inuse++; /* we use it! */    rc = CURLRESOLV_RESOLVED;  }  if(data->share)    Curl_share_unlock(data, CURL_LOCK_DATA_DNS);  if(!dns) {    /* The entry was not in the cache. Resolve it to IP address */    Curl_addrinfo *addr;    int respwait;    /* Check what IP specifics the app has requested and if we can provide it.     * If not, bail out. */    if(!Curl_ipvalid(conn))      return CURLRESOLV_ERROR;    /* If Curl_getaddrinfo() returns NULL, 'respwait' might be set to a       non-zero value indicating that we need to wait for the response to the       resolve call */    addr = Curl_getaddrinfo(conn,#ifdef DEBUGBUILD                            (data->set.str[STRING_DEVICE]                             && !strcmp(data->set.str[STRING_DEVICE],                                        "LocalHost"))?"localhost":#endif                            hostname, port, &respwait);    if(!addr) {      if(respwait) {        /* the response to our resolve call will come asynchronously at           a later time, good or bad */        /* First, check that we haven't received the info by now */        result = Curl_is_resolved(conn, &dns);        if(result) /* error detected */          return CURLRESOLV_ERROR;        if(dns)          rc = CURLRESOLV_RESOLVED; /* pointer provided */        else          rc = CURLRESOLV_PENDING; /* no info yet */      }    }    else {      if(data->share)        Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);      /* we got a response, store it in the cache */      dns = Curl_cache_addr(data, addr, hostname, port);      if(data->share)        Curl_share_unlock(data, CURL_LOCK_DATA_DNS);      if(!dns)        /* returned failure, bail out nicely */        Curl_freeaddrinfo(addr);      else        rc = CURLRESOLV_RESOLVED;    }  }  *entry = dns;  return rc;//.........这里部分代码省略.........

int Curl_resolv(struct connectdata *conn,                const char *hostname,                int port,                struct Curl_dns_entry **entry){  char *entry_id = NULL;  struct Curl_dns_entry *dns = NULL;  size_t entry_len;  int wait;  struct SessionHandle *data = conn->data;  CURLcode result;  int rc;  *entry = NULL;#ifdef HAVE_SIGSETJMP  /* this allows us to time-out from the name resolver, as the timeout     will generate a signal and we will siglongjmp() from that here */  if(!data->set.no_signal) {    if (sigsetjmp(curl_jmpenv, 1)) {      /* this is coming from a siglongjmp() */      failf(data, "name lookup timed out");      return CURLRESOLV_ERROR;    }  }#endif  /* Create an entry id, based upon the hostname and port */  entry_id = create_hostcache_id(hostname, port);  /* If we can't create the entry id, fail */  if (!entry_id)    return CURLRESOLV_ERROR;  entry_len = strlen(entry_id);  if(data->share)    Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);  /* See if its already in our dns cache */  dns = Curl_hash_pick(data->dns.hostcache, entry_id, entry_len+1);  if(data->share)    Curl_share_unlock(data, CURL_LOCK_DATA_DNS);  /* free the allocated entry_id again */  free(entry_id);  /* See whether the returned entry is stale. Deliberately done after the     locked block */  if ( remove_entry_if_stale(data,dns) )    dns = NULL; /* the memory deallocation is being handled by the hash */  rc = CURLRESOLV_ERROR; /* default to failure */  if (!dns) {    /* The entry was not in the cache. Resolve it to IP address */    Curl_addrinfo *addr;    /* Check what IP specifics the app has requested and if we can provide it.     * If not, bail out. */    if(!Curl_ipvalid(data))      return CURLRESOLV_ERROR;    /* If Curl_getaddrinfo() returns NULL, 'wait' might be set to a non-zero       value indicating that we need to wait for the response to the resolve       call */    addr = Curl_getaddrinfo(conn, hostname, port, &wait);    if (!addr) {      if(wait) {        /* the response to our resolve call will come asynchronously at           a later time, good or bad */        /* First, check that we haven't received the info by now */        result = Curl_is_resolved(conn, &dns);        if(result) /* error detected */          return CURLRESOLV_ERROR;        if(dns)          rc = CURLRESOLV_RESOLVED; /* pointer provided */        else          rc = CURLRESOLV_PENDING; /* no info yet */      }    }    else {      if(data->share)        Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);      /* we got a response, store it in the cache */      dns = Curl_cache_addr(data, addr, hostname, port);      if(data->share)        Curl_share_unlock(data, CURL_LOCK_DATA_DNS);      if(!dns)        /* returned failure, bail out nicely */        Curl_freeaddrinfo(addr);      else        rc = CURLRESOLV_RESOLVED;    }  }  else {//.........这里部分代码省略.........

int Curl_resolv(struct connectdata *conn,                const char *hostname,                int port,                struct Curl_dns_entry **entry){  struct Curl_dns_entry *dns = NULL;  struct SessionHandle *data = conn->data;  CURLcode result;  int rc = CURLRESOLV_ERROR; /* default to failure */  *entry = NULL;  if(data->share)    Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);  dns = fetch_addr(conn, hostname, port);  if(dns) {    infof(data, "Hostname %s was found in DNS cache/n", hostname);    dns->inuse++; /* we use it! */    rc = CURLRESOLV_RESOLVED;  }  if(data->share)    Curl_share_unlock(data, CURL_LOCK_DATA_DNS);  if(!dns) {    /* The entry was not in the cache. Resolve it to IP address */    Curl_addrinfo *addr;    int respwait;    /* Check what IP specifics the app has requested and if we can provide it.     * If not, bail out. */    if(!Curl_ipvalid(conn))      return CURLRESOLV_ERROR;    /* If Curl_getaddrinfo() returns NULL, 'respwait' might be set to a       non-zero value indicating that we need to wait for the response to the       resolve call */    addr = Curl_getaddrinfo(conn,#ifdef DEBUGBUILD                            (data->set.str[STRING_DEVICE]                             && !strcmp(data->set.str[STRING_DEVICE],                                        "LocalHost"))?"localhost":#endif                            hostname, port, &respwait);    if(!addr) {      if(respwait) {        /* the response to our resolve call will come asynchronously at           a later time, good or bad */        /* First, check that we haven't received the info by now */        result = Curl_resolver_is_resolved(conn, &dns);        if(result) /* error detected */          return CURLRESOLV_ERROR;        if(dns)          rc = CURLRESOLV_RESOLVED; /* pointer provided */        else          rc = CURLRESOLV_PENDING; /* no info yet */      }    }    else {      if(data->share)        Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);      /* we got a response, store it in the cache */      dns = Curl_cache_addr(data, addr, hostname, port);      if(data->share)        Curl_share_unlock(data, CURL_LOCK_DATA_DNS);      if(!dns)        /* returned failure, bail out nicely */        Curl_freeaddrinfo(addr);      else        rc = CURLRESOLV_RESOLVED;    }  }  *entry = dns;  return rc;}

/* * Unlock shared SSL session data */void Curl_ssl_sessionid_unlock(struct connectdata *conn){  if(SSLSESSION_SHARED(conn->data))    Curl_share_unlock(conn->data, CURL_LOCK_DATA_SSL_SESSION);}

CURLcode Curl_loadhostpairs(struct SessionHandle *data){  struct curl_slist *hostp;  char hostname[256];  char address[256];  int port;  for(hostp = data->change.resolve; hostp; hostp = hostp->next) {    if(!hostp->data)      continue;    if(hostp->data[0] == '-') {      char *entry_id;      size_t entry_len;      if(2 != sscanf(hostp->data + 1, "%255[^:]:%d", hostname, &port)) {        infof(data, "Couldn't parse CURLOPT_RESOLVE removal entry '%s'!/n",              hostp->data);        continue;      }      /* Create an entry id, based upon the hostname and port */      entry_id = create_hostcache_id(hostname, port);      /* If we can't create the entry id, fail */      if(!entry_id) {        return CURLE_OUT_OF_MEMORY;      }      entry_len = strlen(entry_id);      if(data->share)        Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);      /* delete entry, ignore if it didn't exist */      Curl_hash_delete(data->dns.hostcache, entry_id, entry_len+1);      if(data->share)        Curl_share_unlock(data, CURL_LOCK_DATA_DNS);      /* free the allocated entry_id again */      free(entry_id);    }    else {      struct Curl_dns_entry *dns;      Curl_addrinfo *addr;      char *entry_id;      size_t entry_len;      if(3 != sscanf(hostp->data, "%255[^:]:%d:%255s", hostname, &port,                     address)) {        infof(data, "Couldn't parse CURLOPT_RESOLVE entry '%s'!/n",              hostp->data);        continue;      }      addr = Curl_str2addr(address, port);      if(!addr) {        infof(data, "Address in '%s' found illegal!/n", hostp->data);        continue;      }      /* Create an entry id, based upon the hostname and port */      entry_id = create_hostcache_id(hostname, port);      /* If we can't create the entry id, fail */      if(!entry_id) {        Curl_freeaddrinfo(addr);        return CURLE_OUT_OF_MEMORY;      }      entry_len = strlen(entry_id);      if(data->share)        Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);      /* See if its already in our dns cache */      dns = Curl_hash_pick(data->dns.hostcache, entry_id, entry_len+1);      /* free the allocated entry_id again */      free(entry_id);      if(!dns) {        /* if not in the cache already, put this host in the cache */        dns = Curl_cache_addr(data, addr, hostname, port);        if(dns) {          dns->timestamp = 0; /* mark as added by CURLOPT_RESOLVE */          /* release the returned reference; the cache itself will keep the           * entry alive: */          dns->inuse--;        }      }      else        /* this is a duplicate, free it again */        Curl_freeaddrinfo(addr);      if(data->share)        Curl_share_unlock(data, CURL_LOCK_DATA_DNS);      if(!dns) {        Curl_freeaddrinfo(addr);        return CURLE_OUT_OF_MEMORY;      }//.........这里部分代码省略.........

/* * Store session id in the session cache. The ID passed on to this function * must already have been extracted and allocated the proper way for the SSL * layer. Curl_XXXX_session_free() will be called to free/kill the session ID * later on. */CURLcode Curl_ssl_addsessionid(struct connectdata *conn,                               void *ssl_sessionid,                               size_t idsize){    size_t i;    struct SessionHandle *data=conn->data; /* the mother of all structs */    struct curl_ssl_session *store = &data->state.session[0];    long oldest_age=data->state.session[0].age; /* zero if unused */    char *clone_host;    long *general_age;    /* Even though session ID re-use might be disabled, that only disables USING       IT. We still store it here in case the re-using is again enabled for an       upcoming transfer */    clone_host = strdup(conn->host.name);    if(!clone_host)        return CURLE_OUT_OF_MEMORY; /* bail out */    /* Now we should add the session ID and the host name to the cache, (remove       the oldest if necessary) */    /* If using shared SSL session, lock! */    if(SSLSESSION_SHARED(data)) {        Curl_share_lock(data, CURL_LOCK_DATA_SSL_SESSION, CURL_LOCK_ACCESS_SINGLE);        general_age = &data->share->sessionage;    }    else {        general_age = &data->state.sessionage;    }    /* find an empty slot for us, or find the oldest */    for(i = 1; (i < data->set.ssl.max_ssl_sessions) &&            data->state.session[i].sessionid; i++) {        if(data->state.session[i].age < oldest_age) {            oldest_age = data->state.session[i].age;            store = &data->state.session[i];        }    }    if(i == data->set.ssl.max_ssl_sessions)        /* cache is full, we must "kill" the oldest entry! */        Curl_ssl_kill_session(store);    else        store = &data->state.session[i]; /* use this slot */    /* now init the session struct wisely */    store->sessionid = ssl_sessionid;    store->idsize = idsize;    store->age = *general_age;    /* set current age */    if(store->name)        /* free it if there's one already present */        free(store->name);    store->name = clone_host;               /* clone host name */    store->remote_port = conn->remote_port; /* port number */    /* Unlock */    if(SSLSESSION_SHARED(data))        Curl_share_unlock(data, CURL_LOCK_DATA_SSL_SESSION);    if(!Curl_clone_ssl_config(&conn->ssl_config, &store->ssl_config)) {        store->sessionid = NULL; /* let caller free sessionid */        free(clone_host);        return CURLE_OUT_OF_MEMORY;    }    return CURLE_OK;}