lib/getinfo.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
   9  *
  10  * This software is licensed as described in the file COPYING, which
  11  * you should have received as part of this distribution. The terms
  12  * are also available at https://curl.haxx.se/docs/copyright.html.
  13  *
  14  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15  * copies of the Software, and permit persons to whom the Software is
  16  * furnished to do so, under the terms of the COPYING file.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ***************************************************************************/
  22
  23 #include "curl_setup.h"
  24
  25 #include <curl/curl.h>
  26
  27 #include "urldata.h"
  28 #include "getinfo.h"
  29
  30 #include "vtls/vtls.h"
  31 #include "connect.h" /* Curl_getconnectinfo() */
  32 #include "progress.h"
  33
  34 /* The last #include files should be: */
  35 #include "curl_memory.h"
  36 #include "memdebug.h"
  37
  38 /*
  39  * This is supposed to be called in the beginning of a perform() session
  40  * and should reset all session-info variables
  41  */
  42 CURLcode Curl_initinfo(struct Curl_easy *data)
  43 {
  44   struct Progress *pro = &data->progress;
  45   struct PureInfo *info = &data->info;
  46
  47   pro->t_nslookup = 0;
  48   pro->t_connect = 0;
  49   pro->t_appconnect = 0;
  50   pro->t_pretransfer = 0;
  51   pro->t_starttransfer = 0;
  52   pro->timespent = 0;
  53   pro->t_redirect = 0;
  54
  55   info->httpcode = 0;
  56   info->httpproxycode = 0;
  57   info->httpversion = 0;
  58   info->filetime = -1; /* -1 is an illegal time and thus means unknown */
  59   info->timecond = FALSE;
  60
  61   free(info->contenttype);
  62   info->contenttype = NULL;
  63
  64   info->header_size = 0;
  65   info->request_size = 0;
  66   info->numconnects = 0;
  67
  68   info->conn_primary_ip[0] = '\0';
  69   info->conn_local_ip[0] = '\0';
  70   info->conn_primary_port = 0;
  71   info->conn_local_port = 0;
  72
  73   return CURLE_OK;
  74 }
  75
  76 static CURLcode getinfo_char(struct Curl_easy *data, CURLINFO info,
  77                              char **param_charp)
  78 {
  79   switch(info) {
  80   case CURLINFO_EFFECTIVE_URL:
  81     *param_charp = data->change.url?data->change.url:(char *)"";
  82     break;
  83   case CURLINFO_CONTENT_TYPE:
  84     *param_charp = data->info.contenttype;
  85     break;
  86   case CURLINFO_PRIVATE:
  87     *param_charp = (char *) data->set.private_data;
  88     break;
  89   case CURLINFO_FTP_ENTRY_PATH:
  90     /* Return the entrypath string from the most recent connection.
  91        This pointer was copied from the connectdata structure by FTP.
  92        The actual string may be free()ed by subsequent libcurl calls so
  93        it must be copied to a safer area before the next libcurl call.
  94        Callers must never free it themselves. */
  95     *param_charp = data->state.most_recent_ftp_entrypath;
  96     break;
  97   case CURLINFO_REDIRECT_URL:
  98     /* Return the URL this request would have been redirected to if that
  99        option had been enabled! */
 100     *param_charp = data->info.wouldredirect;
 101     break;
 102   case CURLINFO_PRIMARY_IP:
 103     /* Return the ip address of the most recent (primary) connection */
 104     *param_charp = data->info.conn_primary_ip;
 105     break;
 106   case CURLINFO_LOCAL_IP:
 107     /* Return the source/local ip address of the most recent (primary)
 108        connection */
 109     *param_charp = data->info.conn_local_ip;
 110     break;
 111   case CURLINFO_RTSP_SESSION_ID:
 112     *param_charp = data->set.str[STRING_RTSP_SESSION_ID];
 113     break;
 114
 115   default:
 116     return CURLE_UNKNOWN_OPTION;
 117   }
 118
 119   return CURLE_OK;
 120 }
 121
 122 static CURLcode getinfo_long(struct Curl_easy *data, CURLINFO info,
 123                              long *param_longp)
 124 {
 125   curl_socket_t sockfd;
 126
 127   union {
 128     unsigned long *to_ulong;
 129     long          *to_long;
 130   } lptr;
 131
 132   switch(info) {
 133   case CURLINFO_RESPONSE_CODE:
 134     *param_longp = data->info.httpcode;
 135     break;
 136   case CURLINFO_HTTP_CONNECTCODE:
 137     *param_longp = data->info.httpproxycode;
 138     break;
 139   case CURLINFO_FILETIME:
 140     *param_longp = data->info.filetime;
 141     break;
 142   case CURLINFO_HEADER_SIZE:
 143     *param_longp = data->info.header_size;
 144     break;
 145   case CURLINFO_REQUEST_SIZE:
 146     *param_longp = data->info.request_size;
 147     break;
 148   case CURLINFO_SSL_VERIFYRESULT:
 149     *param_longp = data->set.ssl.certverifyresult;
 150     break;
 151   case CURLINFO_REDIRECT_COUNT:
 152     *param_longp = data->set.followlocation;
 153     break;
 154   case CURLINFO_HTTPAUTH_AVAIL:
 155     lptr.to_long = param_longp;
 156     *lptr.to_ulong = data->info.httpauthavail;
 157     break;
 158   case CURLINFO_PROXYAUTH_AVAIL:
 159     lptr.to_long = param_longp;
 160     *lptr.to_ulong = data->info.proxyauthavail;
 161     break;
 162   case CURLINFO_OS_ERRNO:
 163     *param_longp = data->state.os_errno;
 164     break;
 165   case CURLINFO_NUM_CONNECTS:
 166     *param_longp = data->info.numconnects;
 167     break;
 168   case CURLINFO_LASTSOCKET:
 169     sockfd = Curl_getconnectinfo(data, NULL);
 170
 171     /* note: this is not a good conversion for systems with 64 bit sockets and
 172        32 bit longs */
 173     if(sockfd != CURL_SOCKET_BAD)
 174       *param_longp = (long)sockfd;
 175     else
 176       /* this interface is documented to return -1 in case of badness, which
 177          may not be the same as the CURL_SOCKET_BAD value */
 178       *param_longp = -1;
 179     break;
 180   case CURLINFO_PRIMARY_PORT:
 181     /* Return the (remote) port of the most recent (primary) connection */
 182     *param_longp = data->info.conn_primary_port;
 183     break;
 184   case CURLINFO_LOCAL_PORT:
 185     /* Return the local port of the most recent (primary) connection */
 186     *param_longp = data->info.conn_local_port;
 187     break;
 188   case CURLINFO_CONDITION_UNMET:
 189     /* return if the condition prevented the document to get transferred */
 190     *param_longp = data->info.timecond ? 1L : 0L;
 191     break;
 192   case CURLINFO_RTSP_CLIENT_CSEQ:
 193     *param_longp = data->state.rtsp_next_client_CSeq;
 194     break;
 195   case CURLINFO_RTSP_SERVER_CSEQ:
 196     *param_longp = data->state.rtsp_next_server_CSeq;
 197     break;
 198   case CURLINFO_RTSP_CSEQ_RECV:
 199     *param_longp = data->state.rtsp_CSeq_recv;
 200     break;
 201   case CURLINFO_HTTP_VERSION:
 202     switch (data->info.httpversion) {
 203     case 10:
 204       *param_longp = CURL_HTTP_VERSION_1_0;
 205       break;
 206     case 11:
 207       *param_longp = CURL_HTTP_VERSION_1_1;
 208       break;
 209     case 20:
 210       *param_longp = CURL_HTTP_VERSION_2_0;
 211       break;
 212     default:
 213       *param_longp = CURL_HTTP_VERSION_NONE;
 214       break;
 215     }
 216     break;
 217
 218   default:
 219     return CURLE_UNKNOWN_OPTION;
 220   }
 221
 222   return CURLE_OK;
 223 }
 224
 225 static CURLcode getinfo_double(struct Curl_easy *data, CURLINFO info,
 226                                double *param_doublep)
 227 {
 228   switch(info) {
 229   case CURLINFO_TOTAL_TIME:
 230     *param_doublep = data->progress.timespent;
 231     break;
 232   case CURLINFO_NAMELOOKUP_TIME:
 233     *param_doublep = data->progress.t_nslookup;
 234     break;
 235   case CURLINFO_CONNECT_TIME:
 236     *param_doublep = data->progress.t_connect;
 237     break;
 238   case CURLINFO_APPCONNECT_TIME:
 239     *param_doublep = data->progress.t_appconnect;
 240     break;
 241   case CURLINFO_PRETRANSFER_TIME:
 242     *param_doublep =  data->progress.t_pretransfer;
 243     break;
 244   case CURLINFO_STARTTRANSFER_TIME:
 245     *param_doublep = data->progress.t_starttransfer;
 246     break;
 247   case CURLINFO_SIZE_UPLOAD:
 248     *param_doublep =  (double)data->progress.uploaded;
 249     break;
 250   case CURLINFO_SIZE_DOWNLOAD:
 251     *param_doublep = (double)data->progress.downloaded;
 252     break;
 253   case CURLINFO_SPEED_DOWNLOAD:
 254     *param_doublep =  (double)data->progress.dlspeed;
 255     break;
 256   case CURLINFO_SPEED_UPLOAD:
 257     *param_doublep = (double)data->progress.ulspeed;
 258     break;
 259   case CURLINFO_CONTENT_LENGTH_DOWNLOAD:
 260     *param_doublep = (data->progress.flags & PGRS_DL_SIZE_KNOWN)?
 261       (double)data->progress.size_dl:-1;
 262     break;
 263   case CURLINFO_CONTENT_LENGTH_UPLOAD:
 264     *param_doublep = (data->progress.flags & PGRS_UL_SIZE_KNOWN)?
 265       (double)data->progress.size_ul:-1;
 266     break;
 267   case CURLINFO_REDIRECT_TIME:
 268     *param_doublep =  data->progress.t_redirect;
 269     break;
 270
 271   default:
 272     return CURLE_UNKNOWN_OPTION;
 273   }
 274
 275   return CURLE_OK;
 276 }
 277
 278 static CURLcode getinfo_slist(struct Curl_easy *data, CURLINFO info,
 279                               struct curl_slist **param_slistp)
 280 {
 281   union {
 282     struct curl_certinfo *to_certinfo;
 283     struct curl_slist    *to_slist;
 284   } ptr;
 285
 286   switch(info) {
 287   case CURLINFO_SSL_ENGINES:
 288     *param_slistp = Curl_ssl_engines_list(data);
 289     break;
 290   case CURLINFO_COOKIELIST:
 291     *param_slistp = Curl_cookie_list(data);
 292     break;
 293   case CURLINFO_CERTINFO:
 294     /* Return the a pointer to the certinfo struct. Not really an slist
 295        pointer but we can pretend it is here */
 296     ptr.to_certinfo = &data->info.certs;
 297     *param_slistp = ptr.to_slist;
 298     break;
 299   case CURLINFO_TLS_SESSION:
 300   case CURLINFO_TLS_SSL_PTR:
 301     {
 302       struct curl_tlssessioninfo **tsip = (struct curl_tlssessioninfo **)
 303                                           param_slistp;
 304       struct curl_tlssessioninfo *tsi = &data->tsi;
 305       struct connectdata *conn = data->easy_conn;
 306
 307       *tsip = tsi;
 308       tsi->backend = Curl_ssl_backend();
 309       tsi->internals = NULL;
 310
 311       if(conn && tsi->backend != CURLSSLBACKEND_NONE) {
 312         unsigned int i;
 313         for(i = 0; i < (sizeof(conn->ssl) / sizeof(conn->ssl[0])); ++i) {
 314           if(conn->ssl[i].use) {
 315 #if defined(USE_AXTLS)
 316             tsi->internals = (void *)conn->ssl[i].ssl;
 317 #elif defined(USE_CYASSL)
 318             tsi->internals = (void *)conn->ssl[i].handle;
 319 #elif defined(USE_DARWINSSL)
 320             tsi->internals = (void *)conn->ssl[i].ssl_ctx;
 321 #elif defined(USE_GNUTLS)
 322             tsi->internals = (void *)conn->ssl[i].session;
 323 #elif defined(USE_GSKIT)
 324             tsi->internals = (void *)conn->ssl[i].handle;
 325 #elif defined(USE_MBEDTLS)
 326             tsi->internals = (void *)&conn->ssl[i].ssl;
 327 #elif defined(USE_NSS)
 328             tsi->internals = (void *)conn->ssl[i].handle;
 329 #elif defined(USE_OPENSSL)
 330             /* Legacy: CURLINFO_TLS_SESSION must return an SSL_CTX pointer. */
 331             tsi->internals = ((info == CURLINFO_TLS_SESSION) ?
 332                               (void *)conn->ssl[i].ctx :
 333                               (void *)conn->ssl[i].handle);
 334 #elif defined(USE_POLARSSL)
 335             tsi->internals = (void *)&conn->ssl[i].ssl;
 336 #elif defined(USE_SCHANNEL)
 337             tsi->internals = (void *)&conn->ssl[i].ctxt->ctxt_handle;
 338 #elif defined(USE_SSL)
 339 #error "SSL backend specific information missing for CURLINFO_TLS_SSL_PTR"
 340 #endif
 341             break;
 342           }
 343         }
 344       }
 345     }
 346     break;
 347   default:
 348     return CURLE_UNKNOWN_OPTION;
 349   }
 350
 351   return CURLE_OK;
 352 }
 353
 354 static CURLcode getinfo_socket(struct Curl_easy *data, CURLINFO info,
 355                                curl_socket_t *param_socketp)
 356 {
 357   switch(info) {
 358   case CURLINFO_ACTIVESOCKET:
 359     *param_socketp = Curl_getconnectinfo(data, NULL);
 360     break;
 361   default:
 362     return CURLE_UNKNOWN_OPTION;
 363   }
 364
 365   return CURLE_OK;
 366 }
 367
 368 CURLcode Curl_getinfo(struct Curl_easy *data, CURLINFO info, ...)
 369 {
 370   va_list arg;
 371   long *param_longp = NULL;
 372   double *param_doublep = NULL;
 373   char **param_charp = NULL;
 374   struct curl_slist **param_slistp = NULL;
 375   curl_socket_t *param_socketp = NULL;
 376   int type;
 377   CURLcode result = CURLE_UNKNOWN_OPTION;
 378
 379   if(!data)
 380     return result;
 381
 382   va_start(arg, info);
 383
 384   type = CURLINFO_TYPEMASK & (int)info;
 385   switch(type) {
 386   case CURLINFO_STRING:
 387     param_charp = va_arg(arg, char **);
 388     if(param_charp)
 389       result = getinfo_char(data, info, param_charp);
 390     break;
 391   case CURLINFO_LONG:
 392     param_longp = va_arg(arg, long *);
 393     if(param_longp)
 394       result = getinfo_long(data, info, param_longp);
 395     break;
 396   case CURLINFO_DOUBLE:
 397     param_doublep = va_arg(arg, double *);
 398     if(param_doublep)
 399       result = getinfo_double(data, info, param_doublep);
 400     break;
 401   case CURLINFO_SLIST:
 402     param_slistp = va_arg(arg, struct curl_slist **);
 403     if(param_slistp)
 404       result = getinfo_slist(data, info, param_slistp);
 405     break;
 406   case CURLINFO_SOCKET:
 407     param_socketp = va_arg(arg, curl_socket_t *);
 408     if(param_socketp)
 409       result = getinfo_socket(data, info, param_socketp);
 410     break;
 411   default:
 412     break;
 413   }
 414
 415   va_end(arg);
 416
 417   return result;
 418 }