Lines Matching refs:data
83 copy of blob. If CURL_BLOB_COPY is set, the data is copied. */
98 /* put the data after the blob struct in memory */
99 nblob->data = (char *)nblob + sizeof(struct curl_blob);
100 memcpy(nblob->data, blob->data, blob->len);
117 to clear the existing data */
198 CURLcode Curl_vsetopt(struct Curl_easy *data, CURLoption option, va_list param)
214 data->set.dns_cache_timeout = (int)arg;
223 data->set.general_ssl.ca_cache_timeout = (int)arg;
230 result = Curl_setstropt(&data->set.str[STRING_SSL_CIPHER_LIST],
236 result = Curl_setstropt(&data->set.str[STRING_SSL_CIPHER_LIST_PROXY],
241 if(Curl_ssl_supports(data, SSLSUPP_TLS13_CIPHERSUITES)) {
243 result = Curl_setstropt(&data->set.str[STRING_SSL_CIPHER13_LIST],
251 if(Curl_ssl_supports(data, SSLSUPP_TLS13_CIPHERSUITES)) {
253 result = Curl_setstropt(&data->set.str[STRING_SSL_CIPHER13_LIST_PROXY],
272 data->set.maxconnects = (unsigned int)uarg;
279 data->set.reuse_forbid = (0 != va_arg(param, long));
286 data->set.reuse_fresh = (0 != va_arg(param, long));
293 data->set.verbose = (0 != va_arg(param, long));
297 * Set to include the header in the general data output stream.
299 data->set.include_header = (0 != va_arg(param, long));
305 data->set.hide_progress = (0 != va_arg(param, long));
306 if(data->set.hide_progress)
307 data->progress.flags |= PGRS_HIDE;
309 data->progress.flags &= ~PGRS_HIDE;
313 * Do not include the body part in the output data stream.
315 data->set.opt_no_body = (0 != va_arg(param, long));
317 if(data->set.opt_no_body)
319 data->set.method = HTTPREQ_HEAD;
320 else if(data->set.method == HTTPREQ_HEAD)
321 data->set.method = HTTPREQ_GET;
329 data->set.http_fail_on_error = (0 != va_arg(param, long));
332 data->set.http_keep_sending_on_error = (0 != va_arg(param, long));
337 * We want to sent data to the remote host. If this is HTTP, that equals
343 data->set.method = HTTPREQ_PUT;
344 data->set.opt_no_body = FALSE; /* this is implied */
349 data->set.method = HTTPREQ_GET;
352 result = Curl_setstropt(&data->set.str[STRING_TARGET],
360 data->set.get_filetime = (0 != va_arg(param, long));
369 data->set.server_response_timeout = (unsigned int)arg * 1000;
380 data->set.server_response_timeout = (unsigned int)arg;
390 data->set.tftp_no_options = va_arg(param, long) != 0;
394 * TFTP option that specifies the block size to use for data transmission.
399 data->set.tftp_blksize = arg;
410 data->set.use_netrc = (unsigned char)arg;
416 result = Curl_setstropt(&data->set.str[STRING_NETRC_FILE],
427 data->set.prefer_ascii = (0 != va_arg(param, long));
437 data->set.timecondition = (unsigned char)(curl_TimeCond)arg;
444 data->set.timevalue = (time_t)va_arg(param, long);
452 data->set.timevalue = (time_t)va_arg(param, curl_off_t);
466 struct ssl_primary_config *primary = &data->set.ssl.primary;
469 primary = &data->set.proxy_ssl.primary;
497 * A string with POST data. Makes curl HTTP POST. Even if it is NULL.
503 if(!argptr || data->set.postfieldsize == -1)
504 result = Curl_setstropt(&data->set.str[STRING_COPYPOSTFIELDS], argptr);
510 if((data->set.postfieldsize < 0) ||
512 (data->set.postfieldsize > (curl_off_t)((size_t)-1))))
518 data.
520 char *p = Curl_memdup0(argptr, (size_t)data->set.postfieldsize);
521 (void) Curl_setstropt(&data->set.str[STRING_COPYPOSTFIELDS], NULL);
525 data->set.str[STRING_COPYPOSTFIELDS] = p;
529 data->set.postfields = data->set.str[STRING_COPYPOSTFIELDS];
530 data->set.method = HTTPREQ_POST;
535 * Like above, but use static data instead of copying it.
537 data->set.postfields = va_arg(param, void *);
538 /* Release old copied data. */
539 (void) Curl_setstropt(&data->set.str[STRING_COPYPOSTFIELDS], NULL);
540 data->set.method = HTTPREQ_POST;
545 * The size of the POSTFIELD data to prevent libcurl to do strlen() to
552 if(data->set.postfieldsize < bigsize &&
553 data->set.postfields == data->set.str[STRING_COPYPOSTFIELDS]) {
555 (void) Curl_setstropt(&data->set.str[STRING_COPYPOSTFIELDS], NULL);
556 data->set.postfields = NULL;
559 data->set.postfieldsize = bigsize;
564 * The size of the POSTFIELD data to prevent libcurl to do strlen() to
571 if(data->set.postfieldsize < bigsize &&
572 data->set.postfields == data->set.str[STRING_COPYPOSTFIELDS]) {
574 (void) Curl_setstropt(&data->set.str[STRING_COPYPOSTFIELDS], NULL);
575 data->set.postfields = NULL;
578 data->set.postfieldsize = bigsize;
586 data->set.http_auto_referer = (0 != va_arg(param, long));
603 result = Curl_setstropt(&data->set.str[STRING_ENCODING], all);
606 result = Curl_setstropt(&data->set.str[STRING_ENCODING], argptr);
610 data->set.http_transfer_encoding = (0 != va_arg(param, long));
617 data->set.http_follow_location = (0 != va_arg(param, long));
625 data->set.allow_auth_to_other_hosts = (0 != va_arg(param, long));
636 data->set.maxredirs = arg;
654 data->set.keep_post = arg & CURL_REDIR_POST_ALL;
659 CURLOPT_POSTFIELDS isn't used and the POST data is read off the
662 data->set.method = HTTPREQ_POST;
663 data->set.opt_no_body = FALSE; /* this is implied */
666 data->set.method = HTTPREQ_GET;
674 data->set.httppost = va_arg(param, struct curl_httppost *);
675 data->set.method = HTTPREQ_POST_FORM;
676 data->set.opt_no_body = FALSE; /* this is implied */
677 Curl_mime_cleanpart(data->state.formp);
678 Curl_safefree(data->state.formp);
679 data->state.mimepost = NULL;
689 result = Curl_setstropt(&data->set.str[STRING_AWS_SIGV4],
694 if(data->set.str[STRING_AWS_SIGV4])
695 data->set.httpauth = CURLAUTH_AWS_SIGV4;
703 if(data->state.referer_alloc) {
704 Curl_safefree(data->state.referer);
705 data->state.referer_alloc = FALSE;
707 result = Curl_setstropt(&data->set.str[STRING_SET_REFERER],
709 data->state.referer = data->set.str[STRING_SET_REFERER];
716 result = Curl_setstropt(&data->set.str[STRING_USERAGENT],
732 data->set.proxyheaders = va_arg(param, struct curl_slist *);
740 data->set.sep_headers = !!(arg & CURLHEADER_SEPARATE);
748 result = Curl_setstropt(&data->set.str[STRING_COOKIE],
764 cl = curl_slist_append(data->state.cookielist, argptr);
766 curl_slist_free_all(data->state.cookielist);
767 data->state.cookielist = NULL;
770 data->state.cookielist = cl; /* store the list for later use */
774 curl_slist_free_all(data->state.cookielist);
775 data->state.cookielist = NULL;
777 if(!data->share || !data->share->cookies) {
780 Curl_cookie_clearall(data->cookies);
781 Curl_cookie_cleanup(data->cookies);
784 data->cookies = NULL;
794 result = Curl_setstropt(&data->set.str[STRING_COOKIEJAR],
801 newcookies = Curl_cookie_init(data, NULL, data->cookies,
802 data->set.cookiesession);
805 data->cookies = newcookies;
816 data->set.cookiesession = (0 != va_arg(param, long));
827 Curl_share_lock(data, CURL_LOCK_DATA_COOKIE, CURL_LOCK_ACCESS_SINGLE);
828 Curl_cookie_clearall(data->cookies);
829 Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE);
833 Curl_share_lock(data, CURL_LOCK_DATA_COOKIE, CURL_LOCK_ACCESS_SINGLE);
834 Curl_cookie_clearsess(data->cookies);
835 Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE);
839 Curl_flush_cookies(data, FALSE);
843 Curl_cookie_loadfiles(data);
847 if(!data->cookies)
849 data->cookies = Curl_cookie_init(data, NULL, NULL, TRUE);
855 if(!argptr || !data->cookies) {
860 Curl_share_lock(data, CURL_LOCK_DATA_COOKIE, CURL_LOCK_ACCESS_SINGLE);
864 Curl_cookie_add(data, data->cookies, TRUE, FALSE, argptr + 11, NULL,
869 Curl_cookie_add(data, data->cookies, FALSE, FALSE, argptr, NULL,
872 Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE);
885 data->set.method = HTTPREQ_GET;
886 data->set.opt_no_body = FALSE; /* this is implied */
928 data->set.httpwant = (unsigned char)arg;
934 * Expect: 100-continue header before sending the data anyway.
939 data->set.expect_100_timeout = arg;
951 data->set.http09_allowed = !!arg;
959 data->set.http200aliases = va_arg(param, struct curl_slist *);
970 data->set.headers = va_arg(param, struct curl_slist *);
979 result = Curl_mime_set_subparts(&data->set.mimepost,
982 data->set.method = HTTPREQ_POST_MIME;
983 data->set.opt_no_body = FALSE; /* this is implied */
985 Curl_mime_cleanpart(data->state.formp);
986 Curl_safefree(data->state.formp);
987 data->state.mimepost = NULL;
994 data->set.mime_formescape = !!(arg & CURLMIMEOPT_FORMESCAPE);
1009 data->set.httpauth = auth;
1015 data->state.authhost.iestyle = !!(auth & CURLAUTH_DIGEST_IE);
1046 data->set.httpauth = auth;
1054 result = Curl_setstropt(&data->set.str[STRING_CUSTOMREQUEST],
1058 data->set.method = HTTPREQ_CUSTOM;
1068 data->set.tunnel_thru_httpproxy = (0 != va_arg(param, long));
1078 data->set.proxyport = (unsigned short)arg;
1091 data->set.proxyauth = auth;
1097 data->state.authproxy.iestyle = !!(auth & CURLAUTH_DIGEST_IE);
1127 data->set.proxyauth = auth;
1142 result = Curl_setstropt(&data->set.str[STRING_PROXY],
1153 result = Curl_setstropt(&data->set.str[STRING_PRE_PROXY],
1164 data->set.proxytype = (unsigned char)(curl_proxytype)arg;
1173 data->set.proxy_transfer_mode = FALSE;
1176 data->set.proxy_transfer_mode = TRUE;
1186 data->set.socks5auth = (unsigned char)va_arg(param, unsigned long);
1187 if(data->set.socks5auth & ~(CURLAUTH_BASIC | CURLAUTH_GSSAPI))
1197 data->set.socks5_gssapi_nec = (0 != va_arg(param, long));
1206 result = Curl_setstropt(&data->set.str[STRING_PROXY_SERVICE_NAME],
1214 result = Curl_setstropt(&data->set.str[STRING_SERVICE_NAME],
1222 data->set.writeheader = (void *)va_arg(param, void *);
1229 data->set.errorbuffer = va_arg(param, char *);
1236 data->set.out = va_arg(param, void *);
1245 data->set.list_only = (0 != va_arg(param, long));
1253 data->set.remote_append = (0 != va_arg(param, long));
1264 data->set.ftp_filemethod = (unsigned char)arg;
1270 result = Curl_setstropt(&data->set.str[STRING_FTPPORT],
1272 data->set.ftp_use_port = !!(data->set.str[STRING_FTPPORT]);
1276 data->set.ftp_use_eprt = (0 != va_arg(param, long));
1280 data->set.ftp_use_epsv = (0 != va_arg(param, long));
1284 data->set.ftp_use_pret = (0 != va_arg(param, long));
1291 data->set.ftp_ccc = (unsigned char)arg;
1299 data->set.ftp_skip_ip = (0 != va_arg(param, long));
1303 result = Curl_setstropt(&data->set.str[STRING_FTP_ACCOUNT],
1308 result = Curl_setstropt(&data->set.str[STRING_FTP_ALTERNATIVE_TO_USER],
1319 data->set.ftpsslauth = (unsigned char)(curl_ftpauth)arg;
1325 result = Curl_setstropt(&data->set.str[STRING_KRB_LEVEL],
1327 data->set.krb = !!(data->set.str[STRING_KRB_LEVEL]);
1342 data->set.ftp_create_missing_dirs = (unsigned char)arg;
1349 data->set.postquote = va_arg(param, struct curl_slist *);
1355 data->set.prequote = va_arg(param, struct curl_slist *);
1361 data->set.quote = va_arg(param, struct curl_slist *);
1369 data->set.in_set = va_arg(param, void *);
1379 data->set.filesize = arg;
1389 data->set.filesize = bigsize;
1399 data->set.low_speed_limit = arg;
1409 data->set.max_send_speed = bigsize;
1413 * When receiving data faster than CURLOPT_MAX_RECV_SPEED_LARGE bytes per
1419 data->set.max_recv_speed = bigsize;
1429 data->set.low_speed_time = arg;
1435 data->set.uh = va_arg(param, CURLU *);
1441 if(data->state.url_alloc) {
1443 Curl_safefree(data->state.url);
1444 data->state.url_alloc = FALSE;
1446 result = Curl_setstropt(&data->set.str[STRING_SET_URL],
1448 data->state.url = data->set.str[STRING_SET_URL];
1457 data->set.use_port = (unsigned short)arg;
1466 data->set.timeout = (unsigned int)arg * 1000;
1475 data->set.timeout = (unsigned int)uarg;
1484 data->set.connecttimeout = (unsigned int)arg * 1000;
1493 data->set.connecttimeout = (unsigned int)uarg;
1504 data->set.accepttimeout = (unsigned int)uarg;
1513 &data->set.str[STRING_USERNAME],
1514 &data->set.str[STRING_PASSWORD]);
1521 result = Curl_setstropt(&data->set.str[STRING_USERNAME],
1528 result = Curl_setstropt(&data->set.str[STRING_PASSWORD],
1536 result = Curl_setstropt(&data->set.str[STRING_OPTIONS],
1544 result = Curl_setstropt(&data->set.str[STRING_BEARER],
1562 data->set.resolve = va_arg(param, struct curl_slist *);
1563 data->state.resolve = data->set.resolve;
1569 data->set.fprogress = va_arg(param, curl_progress_callback);
1570 if(data->set.fprogress)
1571 data->progress.callback = TRUE; /* no longer internal */
1573 data->progress.callback = FALSE; /* NULL enforces internal */
1580 data->set.fxferinfo = va_arg(param, curl_xferinfo_callback);
1581 if(data->set.fxferinfo)
1582 data->progress.callback = TRUE; /* no longer internal */
1584 data->progress.callback = FALSE; /* NULL enforces internal */
1590 * Custom client data to pass to the progress callback
1592 data->set.progress_client = va_arg(param, void *);
1601 &data->set.str[STRING_PROXYUSERNAME],
1602 &data->set.str[STRING_PROXYPASSWORD]);
1608 result = Curl_setstropt(&data->set.str[STRING_PROXYUSERNAME],
1615 result = Curl_setstropt(&data->set.str[STRING_PROXYPASSWORD],
1622 result = Curl_setstropt(&data->set.str[STRING_NOPROXY],
1631 result = Curl_setstropt(&data->set.str[STRING_SET_RANGE],
1641 data->set.set_resume_from = arg;
1650 data->set.set_resume_from = bigsize;
1656 data->set.fdebug = va_arg(param, curl_debug_callback);
1666 data->set.debugdata = va_arg(param, void *);
1673 data->set.err = va_arg(param, FILE *);
1674 if(!data->set.err)
1675 data->set.err = stderr;
1681 data->set.fwrite_header = va_arg(param, curl_write_callback);
1685 * Set data write callback
1687 data->set.fwrite_func = va_arg(param, curl_write_callback);
1688 if(!data->set.fwrite_func)
1690 data->set.fwrite_func = (curl_write_callback)fwrite;
1694 * Read data callback
1696 data->set.fread_func_set = va_arg(param, curl_read_callback);
1697 if(!data->set.fread_func_set) {
1698 data->set.is_fread_set = 0;
1700 data->set.fread_func_set = (curl_read_callback)fread;
1703 data->set.is_fread_set = 1;
1709 data->set.seek_func = va_arg(param, curl_seek_callback);
1715 data->set.seek_client = va_arg(param, void *);
1721 data->set.ioctl_func = va_arg(param, curl_ioctl_callback);
1725 * I/O control data pointer. Might be NULL.
1727 data->set.ioctl_client = va_arg(param, void *);
1733 result = Curl_setstropt(&data->set.str[STRING_CERT],
1740 result = Curl_setblobopt(&data->set.blobs[BLOB_CERT],
1748 result = Curl_setstropt(&data->set.str[STRING_CERT_PROXY],
1755 result = Curl_setblobopt(&data->set.blobs[BLOB_CERT_PROXY],
1763 result = Curl_setstropt(&data->set.str[STRING_CERT_TYPE],
1771 result = Curl_setstropt(&data->set.str[STRING_CERT_TYPE_PROXY],
1779 result = Curl_setstropt(&data->set.str[STRING_KEY],
1786 result = Curl_setblobopt(&data->set.blobs[BLOB_KEY],
1794 result = Curl_setstropt(&data->set.str[STRING_KEY_PROXY],
1801 result = Curl_setblobopt(&data->set.blobs[BLOB_KEY_PROXY],
1809 result = Curl_setstropt(&data->set.str[STRING_KEY_TYPE],
1817 result = Curl_setstropt(&data->set.str[STRING_KEY_TYPE_PROXY],
1825 result = Curl_setstropt(&data->set.str[STRING_KEY_PASSWD],
1833 result = Curl_setstropt(&data->set.str[STRING_KEY_PASSWD_PROXY],
1843 result = Curl_setstropt(&data->set.str[STRING_SSL_ENGINE], argptr);
1845 result = Curl_ssl_set_engine(data, argptr);
1854 Curl_setstropt(&data->set.str[STRING_SSL_ENGINE], NULL);
1855 result = Curl_ssl_set_engine_default(data);
1861 data->set.crlf = (0 != va_arg(param, long));
1868 data->set.haproxyprotocol = (0 != va_arg(param, long));
1874 result = Curl_setstropt(&data->set.str[STRING_HAPROXY_CLIENT_IP],
1877 data->set.haproxyprotocol = TRUE;
1885 result = Curl_setstropt(&data->set.str[STRING_DEVICE],
1896 data->set.localport = curlx_sltous(arg);
1905 data->set.localportrange = curlx_sltous(arg);
1913 data->set.gssapi_delegation = (unsigned char)uarg&
1920 data->set.ssl.primary.verifypeer = (0 != va_arg(param, long));
1923 Curl_ssl_conn_config_update(data, FALSE);
1930 data->set.doh_verifypeer = (0 != va_arg(param, long));
1938 data->set.proxy_ssl.primary.verifypeer =
1942 Curl_ssl_conn_config_update(data, TRUE);
1954 data->set.ssl.primary.verifyhost = !!(arg & 3);
1957 Curl_ssl_conn_config_update(data, FALSE);
1967 data->set.doh_verifyhost = !!(arg & 3);
1978 data->set.proxy_ssl.primary.verifyhost = (bool)((arg & 3)?TRUE:FALSE);
1980 Curl_ssl_conn_config_update(data, TRUE);
1992 data->set.ssl.primary.verifystatus = (0 != va_arg(param, long));
1995 Curl_ssl_conn_config_update(data, FALSE);
2007 data->set.doh_verifystatus = (0 != va_arg(param, long));
2015 if(Curl_ssl_supports(data, SSLSUPP_SSL_CTX))
2016 data->set.ssl.fsslctx = va_arg(param, curl_ssl_ctx_callback);
2026 if(Curl_ssl_supports(data, SSLSUPP_SSL_CTX))
2027 data->set.ssl.fsslctxp = va_arg(param, void *);
2036 if(!Curl_ssl_false_start(data)) {
2041 data->set.ssl.falsestart = (0 != va_arg(param, long));
2045 if(Curl_ssl_supports(data, SSLSUPP_CERTINFO))
2046 data->set.ssl.certinfo = (0 != va_arg(param, long));
2057 if(Curl_ssl_supports(data, SSLSUPP_PINNEDPUBKEY))
2058 result = Curl_setstropt(&data->set.str[STRING_SSL_PINNEDPUBLICKEY],
2071 if(Curl_ssl_supports(data, SSLSUPP_PINNEDPUBKEY))
2072 result = Curl_setstropt(&data->set.str[STRING_SSL_PINNEDPUBLICKEY_PROXY],
2083 result = Curl_setstropt(&data->set.str[STRING_SSL_CAFILE],
2092 if(Curl_ssl_supports(data, SSLSUPP_CAINFO_BLOB)) {
2093 result = Curl_setblobopt(&data->set.blobs[BLOB_CAINFO],
2106 result = Curl_setstropt(&data->set.str[STRING_SSL_CAFILE_PROXY],
2115 if(Curl_ssl_supports(data, SSLSUPP_CAINFO_BLOB)) {
2116 result = Curl_setblobopt(&data->set.blobs[BLOB_CAINFO_PROXY],
2130 if(Curl_ssl_supports(data, SSLSUPP_CA_PATH))
2132 result = Curl_setstropt(&data->set.str[STRING_SSL_CAPATH],
2145 if(Curl_ssl_supports(data, SSLSUPP_CA_PATH))
2147 result = Curl_setstropt(&data->set.str[STRING_SSL_CAPATH_PROXY],
2159 result = Curl_setstropt(&data->set.str[STRING_SSL_CRLFILE],
2168 result = Curl_setstropt(&data->set.str[STRING_SSL_CRLFILE_PROXY],
2177 result = Curl_setstropt(&data->set.str[STRING_SSL_ISSUERCERT],
2184 result = Curl_setblobopt(&data->set.blobs[BLOB_SSL_ISSUERCERT],
2193 result = Curl_setstropt(&data->set.str[STRING_SSL_ISSUERCERT_PROXY],
2200 result = Curl_setblobopt(&data->set.blobs[BLOB_SSL_ISSUERCERT_PROXY],
2209 data->set.telnet_options = va_arg(param, struct curl_slist *);
2217 if(data->state.buffer)
2229 data->set.buffer_size = (unsigned int)arg;
2244 data->set.upload_buffer_size = (unsigned int)arg;
2245 Curl_safefree(data->state.ulbuf); /* force a realloc next opportunity */
2253 data->set.no_signal = (0 != va_arg(param, long));
2262 if(data->share) {
2263 Curl_share_lock(data, CURL_LOCK_DATA_SHARE, CURL_LOCK_ACCESS_SINGLE);
2265 if(data->dns.hostcachetype == HCACHE_SHARED) {
2266 data->dns.hostcache = NULL;
2267 data->dns.hostcachetype = HCACHE_NONE;
2271 if(data->share->cookies == data->cookies)
2272 data->cookies = NULL;
2276 if(data->share->hsts == data->hsts)
2277 data->hsts = NULL;
2280 if(data->share->sslsession == data->state.session)
2281 data->state.session = NULL;
2284 if(data->psl == &data->share->psl)
2285 data->psl = data->multi? &data->multi->psl: NULL;
2288 data->share->dirty--;
2290 Curl_share_unlock(data, CURL_LOCK_DATA_SHARE);
2291 data->share = NULL;
2296 data->share = set;
2297 if(data->share) {
2299 Curl_share_lock(data, CURL_LOCK_DATA_SHARE, CURL_LOCK_ACCESS_SINGLE);
2301 data->share->dirty++;
2303 if(data->share->specifier & (1<< CURL_LOCK_DATA_DNS)) {
2305 data->dns.hostcache = &data->share->hostcache;
2306 data->dns.hostcachetype = HCACHE_SHARED;
2309 if(data->share->cookies) {
2311 Curl_cookie_cleanup(data->cookies);
2313 data->cookies = data->share->cookies;
2317 if(data->share->hsts) {
2319 Curl_hsts_cleanup(&data->hsts);
2320 data->hsts = data->share->hsts;
2324 if(data->share->sslsession) {
2325 data->set.general_ssl.max_ssl_sessions = data->share->max_ssl_sessions;
2326 data->state.session = data->share->sslsession;
2330 if(data->share->specifier & (1 << CURL_LOCK_DATA_PSL))
2331 data->psl = &data->share->psl;
2334 Curl_share_unlock(data, CURL_LOCK_DATA_SHARE);
2343 * Set private data pointer.
2345 data->set.private_data = va_arg(param, void *);
2355 data->set.max_filesize = arg;
2366 data->set.use_ssl = (unsigned char)arg;
2371 data->set.ssl.primary.ssl_options = (unsigned char)(arg & 0xff);
2372 data->set.ssl.enable_beast = !!(arg & CURLSSLOPT_ALLOW_BEAST);
2373 data->set.ssl.no_revoke = !!(arg & CURLSSLOPT_NO_REVOKE);
2374 data->set.ssl.no_partialchain = !!(arg & CURLSSLOPT_NO_PARTIALCHAIN);
2375 data->set.ssl.revoke_best_effort = !!(arg & CURLSSLOPT_REVOKE_BEST_EFFORT);
2376 data->set.ssl.native_ca_store = !!(arg & CURLSSLOPT_NATIVE_CA);
2377 data->set.ssl.auto_client_cert = !!(arg & CURLSSLOPT_AUTO_CLIENT_CERT);
2385 data->set.proxy_ssl.primary.ssl_options = (unsigned char)(arg & 0xff);
2386 data->set.proxy_ssl.enable_beast = !!(arg & CURLSSLOPT_ALLOW_BEAST);
2387 data->set.proxy_ssl.no_revoke = !!(arg & CURLSSLOPT_NO_REVOKE);
2388 data->set.proxy_ssl.no_partialchain = !!(arg & CURLSSLOPT_NO_PARTIALCHAIN);
2389 data->set.proxy_ssl.revoke_best_effort =
2391 data->set.proxy_ssl.native_ca_store = !!(arg & CURLSSLOPT_NATIVE_CA);
2392 data->set.proxy_ssl.auto_client_cert =
2402 result = Curl_setstropt(&data->set.str[STRING_SSL_EC_CURVES],
2410 data->set.ipver = (unsigned char) arg;
2420 data->set.max_filesize = bigsize;
2428 data->set.tcp_nodelay = (0 != va_arg(param, long));
2432 data->set.ignorecl = (0 != va_arg(param, long));
2437 * No data transfer.
2444 data->set.connect_only = (unsigned char)arg;
2451 data->set.fsockopt = va_arg(param, curl_sockopt_callback);
2456 * socket callback data pointer. Might be NULL.
2458 data->set.sockopt_client = va_arg(param, void *);
2466 data->set.fopensocket = va_arg(param, curl_opensocket_callback);
2471 * socket callback data pointer. Might be NULL.
2473 data->set.opensocket_client = va_arg(param, void *);
2481 data->set.fclosesocket = va_arg(param, curl_closesocket_callback);
2489 data->set.resolver_start = va_arg(param, curl_resolver_start_callback);
2494 * resolver start callback data pointer. Might be NULL.
2496 data->set.resolver_start_client = va_arg(param, void *);
2501 * socket callback data pointer. Might be NULL.
2503 data->set.closesocket_client = va_arg(param, void *);
2507 data->set.ssl.primary.sessionid = (0 != va_arg(param, long));
2509 data->set.proxy_ssl.primary.sessionid = data->set.ssl.primary.sessionid;
2516 data->set.ssh_auth_types = (unsigned int)va_arg(param, long);
2523 result = Curl_setstropt(&data->set.str[STRING_SSH_PUBLIC_KEY],
2531 result = Curl_setstropt(&data->set.str[STRING_SSH_PRIVATE_KEY],
2539 result = Curl_setstropt(&data->set.str[STRING_SSH_HOST_PUBLIC_KEY_MD5],
2547 result = Curl_setstropt(&data->set.str[STRING_SSH_KNOWNHOSTS],
2556 result = Curl_setstropt(&data->set.str[STRING_SSH_HOST_PUBLIC_KEY_SHA256],
2562 data->set.ssh_hostkeyfunc = va_arg(param, curl_sshhostkeycallback);
2567 * Custom client data to pass to the SSH keyfunc callback
2569 data->set.ssh_hostkeyfunc_userp = va_arg(param, void *);
2576 data->set.ssh_keyfunc = va_arg(param, curl_sshkeycallback);
2581 * Custom client data to pass to the SSH keyfunc callback
2583 data->set.ssh_keyfunc_userp = va_arg(param, void *);
2587 data->set.ssh_compression = (0 != va_arg(param, long))?TRUE:FALSE;
2596 data->set.http_te_skip = (0 == va_arg(param, long));
2604 * raw data passed to the application when content encoding is used
2606 data->set.http_ce_skip = (0 == va_arg(param, long));
2617 data->set.new_file_perms = (unsigned int)arg;
2628 data->set.new_directory_perms = (unsigned int)arg;
2644 data->set.scope_id = (unsigned int)uarg;
2653 data->set.allowed_protocols = (curl_prot_t)va_arg(param, long);
2660 data->set.redir_protocols = (curl_prot_t)va_arg(param, long);
2665 result = protocol2num(argptr, &data->set.allowed_protocols);
2673 result = protocol2num(argptr, &data->set.redir_protocols);
2681 result = Curl_setstropt(&data->set.str[STRING_DEFAULT_PROTOCOL],
2687 result = Curl_setstropt(&data->set.str[STRING_MAIL_FROM],
2693 result = Curl_setstropt(&data->set.str[STRING_MAIL_AUTH],
2699 data->set.mail_rcpt = va_arg(param, struct curl_slist *);
2703 data->set.mail_rcpt_allowfails = (0 != va_arg(param, long));
2709 result = Curl_setstropt(&data->set.str[STRING_SASL_AUTHZID],
2715 data->set.sasl_ir = (0 != va_arg(param, long));
2774 data->set.rtspreq = rtspreq;
2784 result = Curl_setstropt(&data->set.str[STRING_RTSP_SESSION_ID],
2793 result = Curl_setstropt(&data->set.str[STRING_RTSP_STREAM_URI],
2801 result = Curl_setstropt(&data->set.str[STRING_RTSP_TRANSPORT],
2811 data->state.rtsp_next_client_CSeq = va_arg(param, long);
2816 data->state.rtsp_next_server_CSeq = va_arg(param, long);
2820 data->set.rtp_out = va_arg(param, void *);
2824 data->set.fwrite_rtp = va_arg(param, curl_write_callback);
2829 data->set.wildcard_enabled = (0 != va_arg(param, long));
2832 data->set.chunk_bgn = va_arg(param, curl_chunk_bgn_callback);
2835 data->set.chunk_end = va_arg(param, curl_chunk_end_callback);
2838 data->set.fnmatch = va_arg(param, curl_fnmatch_callback);
2841 data->set.wildcardptr = va_arg(param, void *);
2844 data->set.fnmatch_data = va_arg(param, void *);
2849 result = Curl_setstropt(&data->set.str[STRING_TLSAUTH_USERNAME],
2854 result = Curl_setstropt(&data->set.str[STRING_TLSAUTH_USERNAME_PROXY],
2859 result = Curl_setstropt(&data->set.str[STRING_TLSAUTH_PASSWORD],
2864 result = Curl_setstropt(&data->set.str[STRING_TLSAUTH_PASSWORD_PROXY],
2883 result = Curl_setstropt(&data->set.str[STRING_DNS_SERVERS],
2887 result = Curl_set_dns_servers(data, data->set.str[STRING_DNS_SERVERS]);
2890 result = Curl_setstropt(&data->set.str[STRING_DNS_INTERFACE],
2894 result = Curl_set_dns_interface(data, data->set.str[STRING_DNS_INTERFACE]);
2897 result = Curl_setstropt(&data->set.str[STRING_DNS_LOCAL_IP4],
2901 result = Curl_set_dns_local_ip4(data, data->set.str[STRING_DNS_LOCAL_IP4]);
2904 result = Curl_setstropt(&data->set.str[STRING_DNS_LOCAL_IP6],
2908 result = Curl_set_dns_local_ip6(data, data->set.str[STRING_DNS_LOCAL_IP6]);
2912 data->set.tcp_keepalive = (0 != va_arg(param, long));
2920 data->set.tcp_keepidle = (int)arg;
2928 data->set.tcp_keepintvl = (int)arg;
2933 data->set.tcp_fastopen = (0 != va_arg(param, long))?TRUE:FALSE;
2941 data->set.ssl_enable_alpn = (0 != va_arg(param, long));
2945 data->set.abstract_unix_socket = FALSE;
2946 result = Curl_setstropt(&data->set.str[STRING_UNIX_SOCKET_PATH],
2950 data->set.abstract_unix_socket = TRUE;
2951 result = Curl_setstropt(&data->set.str[STRING_UNIX_SOCKET_PATH],
2957 data->set.path_as_is = (0 != va_arg(param, long));
2960 data->set.pipewait = (0 != va_arg(param, long));
2966 data->set.priority.weight = (int)arg;
2976 return Curl_data_priority_add_child(dep, data,
2982 data->set.connect_to = va_arg(param, struct curl_slist *);
2985 data->set.suppress_connect_headers = (0 != va_arg(param, long))?TRUE:FALSE;
2991 data->set.happy_eyeballs_timeout = (unsigned int)uarg;
2995 data->set.dns_shuffle_addresses = (0 != va_arg(param, long));
2999 data->set.disallow_username_in_url = (0 != va_arg(param, long));
3003 result = Curl_setstropt(&data->set.str[STRING_DOH],
3005 data->set.doh = data->set.str[STRING_DOH]?TRUE:FALSE;
3012 data->set.upkeep_interval_ms = arg;
3018 data->set.maxage_conn = arg;
3024 data->set.maxlifetime_conn = arg;
3028 data->set.trailer_callback = va_arg(param, curl_trailer_callback);
3033 data->set.trailer_data = va_arg(param, void *);
3038 data->set.hsts_read = va_arg(param, curl_hstsread_callback);
3041 data->set.hsts_read_userp = va_arg(param, void *);
3044 data->set.hsts_write = va_arg(param, curl_hstswrite_callback);
3047 data->set.hsts_write_userp = va_arg(param, void *);
3051 if(!data->hsts) {
3052 data->hsts = Curl_hsts_init();
3053 if(!data->hsts)
3058 result = Curl_setstropt(&data->set.str[STRING_HSTS], argptr);
3064 h = curl_slist_append(data->state.hstslist, argptr);
3066 curl_slist_free_all(data->state.hstslist);
3067 data->state.hstslist = NULL;
3070 data->state.hstslist = h; /* store the list for later use */
3074 curl_slist_free_all(data->state.hstslist);
3075 data->state.hstslist = NULL;
3076 if(!data->share || !data->share->hsts)
3078 Curl_hsts_cleanup(&data->hsts);
3085 if(!data->hsts) {
3086 data->hsts = Curl_hsts_init();
3087 if(!data->hsts)
3092 Curl_hsts_cleanup(&data->hsts);
3097 if(!data->asi) {
3098 data->asi = Curl_altsvc_init();
3099 if(!data->asi)
3103 result = Curl_setstropt(&data->set.str[STRING_ALTSVC], argptr);
3107 (void)Curl_altsvc_load(data->asi, argptr);
3110 if(!data->asi) {
3111 data->asi = Curl_altsvc_init();
3112 if(!data->asi)
3117 DEBUGF(infof(data, "bad CURLOPT_ALTSVC_CTRL input"));
3120 result = Curl_altsvc_ctrl(data->asi, arg);
3126 data->set.fprereq = va_arg(param, curl_prereq_callback);
3129 data->set.prereq_userp = va_arg(param, void *);
3136 data->set.ws_raw_mode = raw;
3141 data->set.quick_exit = (0 != va_arg(param, long)) ? 1L:0L;
3161 CURLcode curl_easy_setopt(struct Curl_easy *data, CURLoption tag, ...)
3166 if(!data)
3171 result = Curl_vsetopt(data, tag, arg);
3176 infof(data, "setopt arg 0x%x returned CURLE_BAD_FUNCTION_ARGUMENT", tag);