getinfo.c@ 108333

最後變更在這個檔案從108333是 108048,由 vboxsync 提交於 7 週前
curl-8.11.1: Applied and adjusted our curl changes to 8.7.1. jiraref:VBP-1535
屬性 svn:eol-style 設為 `native`
檔案大小: 17.6 KB

行
1	/***************************************************************************
2	* _ _ ____ _
3	* Project ___\| \| \| \| _ \\| \|
4	* / __\| \| \| \| \|_) \| \|
5	* \| (__\| \|_\| \| _ <\| \|___
6	* \___\|\___/\|_\| \_\_____\|
7	*
8	* Copyright (C) Daniel Stenberg, <[email protected]>, 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.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	* SPDX-License-Identifier: curl
22	*
23	***************************************************************************/
24
25	#include "curl_setup.h"
26
27	#include <curl/curl.h>
28
29	#include "urldata.h"
30	#include "getinfo.h"
31
32	#include "vtls/vtls.h"
33	#include "connect.h" /* Curl_getconnectinfo() */
34	#include "progress.h"
35
36	/* The last #include files should be: */
37	#include "curl_memory.h"
38	#include "memdebug.h"
39
40	/*
41	* Initialize statistical and informational data.
42	*
43	* This function is called in curl_easy_reset, curl_easy_duphandle and at the
44	* beginning of a perform session. It must reset the session-info variables,
45	* in particular all variables in struct PureInfo.
46	*/
47	CURLcode Curl_initinfo(struct Curl_easy *data)
48	{
49	struct Progress *pro = &data->progress;
50	struct PureInfo *info = &data->info;
51
52	pro->t_nslookup = 0;
53	pro->t_connect = 0;
54	pro->t_appconnect = 0;
55	pro->t_pretransfer = 0;
56	pro->t_posttransfer = 0;
57	pro->t_starttransfer = 0;
58	pro->timespent = 0;
59	pro->t_redirect = 0;
60	pro->is_t_startransfer_set = FALSE;
61
62	info->httpcode = 0;
63	info->httpproxycode = 0;
64	info->httpversion = 0;
65	info->filetime = -1; /* -1 is an illegal time and thus means unknown */
66	info->timecond = FALSE;
67
68	info->header_size = 0;
69	info->request_size = 0;
70	info->proxyauthavail = 0;
71	info->httpauthavail = 0;
72	info->numconnects = 0;
73
74	free(info->contenttype);
75	info->contenttype = NULL;
76
77	free(info->wouldredirect);
78	info->wouldredirect = NULL;
79
80	memset(&info->primary, 0, sizeof(info->primary));
81	info->primary.remote_port = -1;
82	info->primary.local_port = -1;
83	info->retry_after = 0;
84
85	info->conn_scheme = 0;
86	info->conn_protocol = 0;
87
88	#ifdef USE_SSL
89	Curl_ssl_free_certinfo(data);
90	#endif
91	return CURLE_OK;
92	}
93
94	static CURLcode getinfo_char(struct Curl_easy *data, CURLINFO info,
95	const char **param_charp)
96	{
97	switch(info) {
98	case CURLINFO_EFFECTIVE_URL:
99	param_charp = data->state.url ? data->state.url : (char )"";
100	break;
101	case CURLINFO_EFFECTIVE_METHOD: {
102	const char *m = data->set.str[STRING_CUSTOMREQUEST];
103	if(!m) {
104	if(data->set.opt_no_body)
105	m = "HEAD";
106	#ifndef CURL_DISABLE_HTTP
107	else {
108	switch(data->state.httpreq) {
109	case HTTPREQ_POST:
110	case HTTPREQ_POST_FORM:
111	case HTTPREQ_POST_MIME:
112	m = "POST";
113	break;
114	case HTTPREQ_PUT:
115	m = "PUT";
116	break;
117	default: /* this should never happen */
118	case HTTPREQ_GET:
119	m = "GET";
120	break;
121	case HTTPREQ_HEAD:
122	m = "HEAD";
123	break;
124	}
125	}
126	#endif
127	}
128	*param_charp = m;
129	}
130	break;
131	case CURLINFO_CONTENT_TYPE:
132	*param_charp = data->info.contenttype;
133	break;
134	case CURLINFO_PRIVATE:
135	param_charp = (char ) data->set.private_data;
136	break;
137	case CURLINFO_FTP_ENTRY_PATH:
138	/* Return the entrypath string from the most recent connection.
139	This pointer was copied from the connectdata structure by FTP.
140	The actual string may be free()ed by subsequent libcurl calls so
141	it must be copied to a safer area before the next libcurl call.
142	Callers must never free it themselves. */
143	*param_charp = data->state.most_recent_ftp_entrypath;
144	break;
145	case CURLINFO_REDIRECT_URL:
146	/* Return the URL this request would have been redirected to if that
147	option had been enabled! */
148	*param_charp = data->info.wouldredirect;
149	break;
150	case CURLINFO_REFERER:
151	/* Return the referrer header for this request, or NULL if unset */
152	*param_charp = data->state.referer;
153	break;
154	case CURLINFO_PRIMARY_IP:
155	/* Return the ip address of the most recent (primary) connection */
156	*param_charp = data->info.primary.remote_ip;
157	break;
158	case CURLINFO_LOCAL_IP:
159	/* Return the source/local ip address of the most recent (primary)
160	connection */
161	*param_charp = data->info.primary.local_ip;
162	break;
163	case CURLINFO_RTSP_SESSION_ID:
164	#ifndef CURL_DISABLE_RTSP
165	*param_charp = data->set.str[STRING_RTSP_SESSION_ID];
166	#else
167	*param_charp = NULL;
168	#endif
169	break;
170	case CURLINFO_SCHEME:
171	*param_charp = data->info.conn_scheme;
172	break;
173	case CURLINFO_CAPATH:
174	#ifdef CURL_CA_PATH
175	*param_charp = CURL_CA_PATH;
176	#else
177	*param_charp = NULL;
178	#endif
179	break;
180	case CURLINFO_CAINFO:
181	#ifdef CURL_CA_BUNDLE
182	*param_charp = CURL_CA_BUNDLE;
183	#else
184	*param_charp = NULL;
185	#endif
186	break;
187	default:
188	return CURLE_UNKNOWN_OPTION;
189	}
190
191	return CURLE_OK;
192	}
193
194	static CURLcode getinfo_long(struct Curl_easy *data, CURLINFO info,
195	long *param_longp)
196	{
197	curl_socket_t sockfd;
198
199	union {
200	unsigned long *to_ulong;
201	long *to_long;
202	} lptr;
203
204	#ifdef DEBUGBUILD
205	char *timestr = getenv("CURL_TIME");
206	if(timestr) {
207	unsigned long val = strtoul(timestr, NULL, 10);
208	switch(info) {
209	case CURLINFO_LOCAL_PORT:
210	*param_longp = (long)val;
211	return CURLE_OK;
212	default:
213	break;
214	}
215	}
216	/* use another variable for this to allow different values */
217	timestr = getenv("CURL_DEBUG_SIZE");
218	if(timestr) {
219	unsigned long val = strtoul(timestr, NULL, 10);
220	switch(info) {
221	case CURLINFO_HEADER_SIZE:
222	case CURLINFO_REQUEST_SIZE:
223	*param_longp = (long)val;
224	return CURLE_OK;
225	default:
226	break;
227	}
228	}
229	#endif
230
231	switch(info) {
232	case CURLINFO_RESPONSE_CODE:
233	*param_longp = data->info.httpcode;
234	break;
235	case CURLINFO_HTTP_CONNECTCODE:
236	*param_longp = data->info.httpproxycode;
237	break;
238	case CURLINFO_FILETIME:
239	if(data->info.filetime > LONG_MAX)
240	*param_longp = LONG_MAX;
241	else if(data->info.filetime < LONG_MIN)
242	*param_longp = LONG_MIN;
243	else
244	*param_longp = (long)data->info.filetime;
245	break;
246	case CURLINFO_HEADER_SIZE:
247	*param_longp = (long)data->info.header_size;
248	break;
249	case CURLINFO_REQUEST_SIZE:
250	*param_longp = (long)data->info.request_size;
251	break;
252	case CURLINFO_SSL_VERIFYRESULT:
253	*param_longp = data->set.ssl.certverifyresult;
254	break;
255	case CURLINFO_PROXY_SSL_VERIFYRESULT:
256	#ifndef CURL_DISABLE_PROXY
257	*param_longp = data->set.proxy_ssl.certverifyresult;
258	#else
259	*param_longp = 0;
260	#endif
261	break;
262	case CURLINFO_REDIRECT_COUNT:
263	*param_longp = data->state.followlocation;
264	break;
265	case CURLINFO_HTTPAUTH_AVAIL:
266	lptr.to_long = param_longp;
267	*lptr.to_ulong = data->info.httpauthavail;
268	break;
269	case CURLINFO_PROXYAUTH_AVAIL:
270	lptr.to_long = param_longp;
271	*lptr.to_ulong = data->info.proxyauthavail;
272	break;
273	case CURLINFO_OS_ERRNO:
274	*param_longp = data->state.os_errno;
275	break;
276	case CURLINFO_NUM_CONNECTS:
277	*param_longp = data->info.numconnects;
278	break;
279	case CURLINFO_LASTSOCKET:
280	sockfd = Curl_getconnectinfo(data, NULL);
281
282	/* note: this is not a good conversion for systems with 64-bit sockets and
283	32-bit longs */
284	if(sockfd != CURL_SOCKET_BAD)
285	*param_longp = (long)sockfd;
286	else
287	/* this interface is documented to return -1 in case of badness, which
288	may not be the same as the CURL_SOCKET_BAD value */
289	*param_longp = -1;
290	break;
291	case CURLINFO_PRIMARY_PORT:
292	/* Return the (remote) port of the most recent (primary) connection */
293	*param_longp = data->info.primary.remote_port;
294	break;
295	case CURLINFO_LOCAL_PORT:
296	/* Return the local port of the most recent (primary) connection */
297	*param_longp = data->info.primary.local_port;
298	break;
299	case CURLINFO_PROXY_ERROR:
300	*param_longp = (long)data->info.pxcode;
301	break;
302	case CURLINFO_CONDITION_UNMET:
303	if(data->info.httpcode == 304)
304	*param_longp = 1L;
305	else
306	/* return if the condition prevented the document to get transferred */
307	*param_longp = data->info.timecond ? 1L : 0L;
308	break;
309	#ifndef CURL_DISABLE_RTSP
310	case CURLINFO_RTSP_CLIENT_CSEQ:
311	*param_longp = data->state.rtsp_next_client_CSeq;
312	break;
313	case CURLINFO_RTSP_SERVER_CSEQ:
314	*param_longp = data->state.rtsp_next_server_CSeq;
315	break;
316	case CURLINFO_RTSP_CSEQ_RECV:
317	*param_longp = data->state.rtsp_CSeq_recv;
318	break;
319	#else
320	case CURLINFO_RTSP_CLIENT_CSEQ:
321	case CURLINFO_RTSP_SERVER_CSEQ:
322	case CURLINFO_RTSP_CSEQ_RECV:
323	*param_longp = 0;
324	break;
325	#endif
326	case CURLINFO_HTTP_VERSION:
327	switch(data->info.httpversion) {
328	case 10:
329	*param_longp = CURL_HTTP_VERSION_1_0;
330	break;
331	case 11:
332	*param_longp = CURL_HTTP_VERSION_1_1;
333	break;
334	case 20:
335	*param_longp = CURL_HTTP_VERSION_2_0;
336	break;
337	case 30:
338	*param_longp = CURL_HTTP_VERSION_3;
339	break;
340	default:
341	*param_longp = CURL_HTTP_VERSION_NONE;
342	break;
343	}
344	break;
345	case CURLINFO_PROTOCOL:
346	*param_longp = (long)data->info.conn_protocol;
347	break;
348	case CURLINFO_USED_PROXY:
349	*param_longp =
350	#ifdef CURL_DISABLE_PROXY
351	0
352	#else
353	data->info.used_proxy
354	#endif
355	;
356	break;
357	default:
358	return CURLE_UNKNOWN_OPTION;
359	}
360
361	return CURLE_OK;
362	}
363
364	#define DOUBLE_SECS(x) (double)(x)/1000000
365
366	static CURLcode getinfo_offt(struct Curl_easy *data, CURLINFO info,
367	curl_off_t *param_offt)
368	{
369	#ifdef DEBUGBUILD
370	char *timestr = getenv("CURL_TIME");
371	if(timestr) {
372	unsigned long val = strtoul(timestr, NULL, 10);
373	switch(info) {
374	case CURLINFO_TOTAL_TIME_T:
375	case CURLINFO_NAMELOOKUP_TIME_T:
376	case CURLINFO_CONNECT_TIME_T:
377	case CURLINFO_APPCONNECT_TIME_T:
378	case CURLINFO_PRETRANSFER_TIME_T:
379	case CURLINFO_POSTTRANSFER_TIME_T:
380	case CURLINFO_STARTTRANSFER_TIME_T:
381	case CURLINFO_REDIRECT_TIME_T:
382	case CURLINFO_SPEED_DOWNLOAD_T:
383	case CURLINFO_SPEED_UPLOAD_T:
384	*param_offt = (curl_off_t)val;
385	return CURLE_OK;
386	default:
387	break;
388	}
389	}
390	#endif
391	switch(info) {
392	case CURLINFO_FILETIME_T:
393	*param_offt = (curl_off_t)data->info.filetime;
394	break;
395	case CURLINFO_SIZE_UPLOAD_T:
396	*param_offt = data->progress.ul.cur_size;
397	break;
398	case CURLINFO_SIZE_DOWNLOAD_T:
399	*param_offt = data->progress.dl.cur_size;
400	break;
401	case CURLINFO_SPEED_DOWNLOAD_T:
402	*param_offt = data->progress.dl.speed;
403	break;
404	case CURLINFO_SPEED_UPLOAD_T:
405	*param_offt = data->progress.ul.speed;
406	break;
407	case CURLINFO_CONTENT_LENGTH_DOWNLOAD_T:
408	*param_offt = (data->progress.flags & PGRS_DL_SIZE_KNOWN) ?
409	data->progress.dl.total_size : -1;
410	break;
411	case CURLINFO_CONTENT_LENGTH_UPLOAD_T:
412	*param_offt = (data->progress.flags & PGRS_UL_SIZE_KNOWN) ?
413	data->progress.ul.total_size : -1;
414	break;
415	case CURLINFO_TOTAL_TIME_T:
416	*param_offt = data->progress.timespent;
417	break;
418	case CURLINFO_NAMELOOKUP_TIME_T:
419	*param_offt = data->progress.t_nslookup;
420	break;
421	case CURLINFO_CONNECT_TIME_T:
422	*param_offt = data->progress.t_connect;
423	break;
424	case CURLINFO_APPCONNECT_TIME_T:
425	*param_offt = data->progress.t_appconnect;
426	break;
427	case CURLINFO_PRETRANSFER_TIME_T:
428	*param_offt = data->progress.t_pretransfer;
429	break;
430	case CURLINFO_POSTTRANSFER_TIME_T:
431	*param_offt = data->progress.t_posttransfer;
432	break;
433	case CURLINFO_STARTTRANSFER_TIME_T:
434	*param_offt = data->progress.t_starttransfer;
435	break;
436	case CURLINFO_QUEUE_TIME_T:
437	*param_offt = data->progress.t_postqueue;
438	break;
439	case CURLINFO_REDIRECT_TIME_T:
440	*param_offt = data->progress.t_redirect;
441	break;
442	case CURLINFO_RETRY_AFTER:
443	*param_offt = data->info.retry_after;
444	break;
445	case CURLINFO_XFER_ID:
446	*param_offt = data->id;
447	break;
448	case CURLINFO_CONN_ID:
449	*param_offt = data->conn ?
450	data->conn->connection_id : data->state.recent_conn_id;
451	break;
452	case CURLINFO_EARLYDATA_SENT_T:
453	*param_offt = data->progress.earlydata_sent;
454	break;
455	default:
456	return CURLE_UNKNOWN_OPTION;
457	}
458
459	return CURLE_OK;
460	}
461
462	static CURLcode getinfo_double(struct Curl_easy *data, CURLINFO info,
463	double *param_doublep)
464	{
465	#ifdef DEBUGBUILD
466	char *timestr = getenv("CURL_TIME");
467	if(timestr) {
468	unsigned long val = strtoul(timestr, NULL, 10);
469	switch(info) {
470	case CURLINFO_TOTAL_TIME:
471	case CURLINFO_NAMELOOKUP_TIME:
472	case CURLINFO_CONNECT_TIME:
473	case CURLINFO_APPCONNECT_TIME:
474	case CURLINFO_PRETRANSFER_TIME:
475	case CURLINFO_STARTTRANSFER_TIME:
476	case CURLINFO_REDIRECT_TIME:
477	case CURLINFO_SPEED_DOWNLOAD:
478	case CURLINFO_SPEED_UPLOAD:
479	*param_doublep = (double)val;
480	return CURLE_OK;
481	default:
482	break;
483	}
484	}
485	#endif
486	switch(info) {
487	case CURLINFO_TOTAL_TIME:
488	*param_doublep = DOUBLE_SECS(data->progress.timespent);
489	break;
490	case CURLINFO_NAMELOOKUP_TIME:
491	*param_doublep = DOUBLE_SECS(data->progress.t_nslookup);
492	break;
493	case CURLINFO_CONNECT_TIME:
494	*param_doublep = DOUBLE_SECS(data->progress.t_connect);
495	break;
496	case CURLINFO_APPCONNECT_TIME:
497	*param_doublep = DOUBLE_SECS(data->progress.t_appconnect);
498	break;
499	case CURLINFO_PRETRANSFER_TIME:
500	*param_doublep = DOUBLE_SECS(data->progress.t_pretransfer);
501	break;
502	case CURLINFO_STARTTRANSFER_TIME:
503	*param_doublep = DOUBLE_SECS(data->progress.t_starttransfer);
504	break;
505	case CURLINFO_SIZE_UPLOAD:
506	*param_doublep = (double)data->progress.ul.cur_size;
507	break;
508	case CURLINFO_SIZE_DOWNLOAD:
509	*param_doublep = (double)data->progress.dl.cur_size;
510	break;
511	case CURLINFO_SPEED_DOWNLOAD:
512	*param_doublep = (double)data->progress.dl.speed;
513	break;
514	case CURLINFO_SPEED_UPLOAD:
515	*param_doublep = (double)data->progress.ul.speed;
516	break;
517	case CURLINFO_CONTENT_LENGTH_DOWNLOAD:
518	*param_doublep = (data->progress.flags & PGRS_DL_SIZE_KNOWN) ?
519	(double)data->progress.dl.total_size : -1;
520	break;
521	case CURLINFO_CONTENT_LENGTH_UPLOAD:
522	*param_doublep = (data->progress.flags & PGRS_UL_SIZE_KNOWN) ?
523	(double)data->progress.ul.total_size : -1;
524	break;
525	case CURLINFO_REDIRECT_TIME:
526	*param_doublep = DOUBLE_SECS(data->progress.t_redirect);
527	break;
528
529	default:
530	return CURLE_UNKNOWN_OPTION;
531	}
532
533	return CURLE_OK;
534	}
535
536	static CURLcode getinfo_slist(struct Curl_easy *data, CURLINFO info,
537	struct curl_slist **param_slistp)
538	{
539	union {
540	struct curl_certinfo *to_certinfo;
541	struct curl_slist *to_slist;
542	} ptr;
543
544	switch(info) {
545	case CURLINFO_SSL_ENGINES:
546	*param_slistp = Curl_ssl_engines_list(data);
547	break;
548	case CURLINFO_COOKIELIST:
549	*param_slistp = Curl_cookie_list(data);
550	break;
551	case CURLINFO_CERTINFO:
552	/* Return the a pointer to the certinfo struct. Not really an slist
553	pointer but we can pretend it is here */
554	ptr.to_certinfo = &data->info.certs;
555	*param_slistp = ptr.to_slist;
556	break;
557	case CURLINFO_TLS_SESSION:
558	case CURLINFO_TLS_SSL_PTR:
559	{
560	struct curl_tlssessioninfo tsip = (struct curl_tlssessioninfo )
561	param_slistp;
562	struct curl_tlssessioninfo *tsi = &data->tsi;
563	#ifdef USE_SSL
564	struct connectdata *conn = data->conn;
565	#endif
566
567	*tsip = tsi;
568	tsi->backend = Curl_ssl_backend();
569	tsi->internals = NULL;
570
571	#ifdef USE_SSL
572	if(conn && tsi->backend != CURLSSLBACKEND_NONE) {
573	tsi->internals = Curl_ssl_get_internals(data, FIRSTSOCKET, info, 0);
574	}
575	#endif
576	}
577	break;
578	default:
579	return CURLE_UNKNOWN_OPTION;
580	}
581
582	return CURLE_OK;
583	}
584
585	static CURLcode getinfo_socket(struct Curl_easy *data, CURLINFO info,
586	curl_socket_t *param_socketp)
587	{
588	switch(info) {
589	case CURLINFO_ACTIVESOCKET:
590	*param_socketp = Curl_getconnectinfo(data, NULL);
591	break;
592	default:
593	return CURLE_UNKNOWN_OPTION;
594	}
595
596	return CURLE_OK;
597	}
598
599	CURLcode Curl_getinfo(struct Curl_easy *data, CURLINFO info, ...)
600	{
601	va_list arg;
602	long *param_longp = NULL;
603	double *param_doublep = NULL;
604	curl_off_t *param_offt = NULL;
605	const char **param_charp = NULL;
606	struct curl_slist **param_slistp = NULL;
607	curl_socket_t *param_socketp = NULL;
608	int type;
609	CURLcode result = CURLE_UNKNOWN_OPTION;
610
611	if(!data)
612	return CURLE_BAD_FUNCTION_ARGUMENT;
613
614	va_start(arg, info);
615
616	type = CURLINFO_TYPEMASK & (int)info;
617	switch(type) {
618	case CURLINFO_STRING:
619	param_charp = va_arg(arg, const char **);
620	if(param_charp)
621	result = getinfo_char(data, info, param_charp);
622	break;
623	case CURLINFO_LONG:
624	param_longp = va_arg(arg, long *);
625	if(param_longp)
626	result = getinfo_long(data, info, param_longp);
627	break;
628	case CURLINFO_DOUBLE:
629	param_doublep = va_arg(arg, double *);
630	if(param_doublep)
631	result = getinfo_double(data, info, param_doublep);
632	break;
633	case CURLINFO_OFF_T:
634	param_offt = va_arg(arg, curl_off_t *);
635	if(param_offt)
636	result = getinfo_offt(data, info, param_offt);
637	break;
638	case CURLINFO_SLIST:
639	param_slistp = va_arg(arg, struct curl_slist **);
640	if(param_slistp)
641	result = getinfo_slist(data, info, param_slistp);
642	break;
643	case CURLINFO_SOCKET:
644	param_socketp = va_arg(arg, curl_socket_t *);
645	if(param_socketp)
646	result = getinfo_socket(data, info, param_socketp);
647	break;
648	default:
649	break;
650	}
651
652	va_end(arg);
653
654	return result;
655	}

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/libs/curl-8.11.1/lib/getinfo.c@ 108333

以其他格式下載: