mirror of
https://github.com/git/git.git
synced 2024-05-06 00:36:14 +02:00
Merge branch 'ab/http-drop-old-curl'
Support for ancient versions of cURL library (pre 7.19.4) has been dropped. * ab/http-drop-old-curl: http: rename CURLOPT_FILE to CURLOPT_WRITEDATA http: drop support for curl < 7.19.3 and < 7.17.0 (again) http: drop support for curl < 7.19.4 http: drop support for curl < 7.16.0 http: drop support for curl < 7.11.1
This commit is contained in:
Junio C Hamano
commit
e48a623dea
29
http-push.c
29
http-push.c
|
|
@ -203,10 +203,8 @@ static void curl_setup_http(CURL *curl, const char *url,
|
|||
curl_easy_setopt(curl, CURLOPT_INFILE, buffer);
|
||||
curl_easy_setopt(curl, CURLOPT_INFILESIZE, buffer->buf.len);
|
||||
curl_easy_setopt(curl, CURLOPT_READFUNCTION, fread_buffer);
|
||||
#ifndef NO_CURL_IOCTL
|
||||
curl_easy_setopt(curl, CURLOPT_IOCTLFUNCTION, ioctl_buffer);
|
||||
curl_easy_setopt(curl, CURLOPT_IOCTLDATA, buffer);
|
||||
#endif
|
||||
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_fn);
|
||||
curl_easy_setopt(curl, CURLOPT_NOBODY, 0);
|
||||
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, custom_req);
|
||||
|
|
@ -249,8 +247,6 @@ static void process_response(void *callback_data)
|
|||
finish_request(request);
|
||||
}
|
||||
|
||||
#ifdef USE_CURL_MULTI
|
||||
|
||||
static void start_fetch_loose(struct transfer_request *request)
|
||||
{
|
||||
struct active_request_slot *slot;
|
||||
|
|
@ -299,7 +295,6 @@ static void start_mkcol(struct transfer_request *request)
|
|||
FREE_AND_NULL(request->url);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
static void start_fetch_packed(struct transfer_request *request)
|
||||
{
|
||||
|
|
@ -605,7 +600,6 @@ static void finish_request(struct transfer_request *request)
|
|||
}
|
||||
}
|
||||
|
||||
#ifdef USE_CURL_MULTI
|
||||
static int is_running_queue;
|
||||
static int fill_active_slot(void *unused)
|
||||
{
|
||||
|
|
@ -629,7 +623,6 @@ static int fill_active_slot(void *unused)
|
|||
}
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
static void get_remote_object_list(unsigned char parent);
|
||||
|
||||
|
|
@ -658,10 +651,8 @@ static void add_fetch_request(struct object *obj)
|
|||
request->next = request_queue_head;
|
||||
request_queue_head = request;
|
||||
|
||||
#ifdef USE_CURL_MULTI
|
||||
fill_active_slots();
|
||||
step_active_slots();
|
||||
#endif
|
||||
}
|
||||
|
||||
static int add_send_request(struct object *obj, struct remote_lock *lock)
|
||||
|
|
@ -696,10 +687,8 @@ static int add_send_request(struct object *obj, struct remote_lock *lock)
|
|||
request->next = request_queue_head;
|
||||
request_queue_head = request;
|
||||
|
||||
#ifdef USE_CURL_MULTI
|
||||
fill_active_slots();
|
||||
step_active_slots();
|
||||
#endif
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -894,7 +883,7 @@ static struct remote_lock *lock_remote(const char *path, long timeout)
|
|||
slot->results = &results;
|
||||
curl_setup_http(slot->curl, url, DAV_LOCK, &out_buffer, fwrite_buffer);
|
||||
curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
|
||||
curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
|
||||
curl_easy_setopt(slot->curl, CURLOPT_WRITEDATA, &in_buffer);
|
||||
|
||||
CALLOC_ARRAY(lock, 1);
|
||||
lock->timeout = -1;
|
||||
|
|
@ -1153,7 +1142,7 @@ static void remote_ls(const char *path, int flags,
|
|||
curl_setup_http(slot->curl, url, DAV_PROPFIND,
|
||||
&out_buffer, fwrite_buffer);
|
||||
curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
|
||||
curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
|
||||
curl_easy_setopt(slot->curl, CURLOPT_WRITEDATA, &in_buffer);
|
||||
|
||||
if (start_active_slot(slot)) {
|
||||
run_active_slot(slot);
|
||||
|
|
@ -1227,7 +1216,7 @@ static int locking_available(void)
|
|||
curl_setup_http(slot->curl, repo->url, DAV_PROPFIND,
|
||||
&out_buffer, fwrite_buffer);
|
||||
curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
|
||||
curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
|
||||
curl_easy_setopt(slot->curl, CURLOPT_WRITEDATA, &in_buffer);
|
||||
|
||||
if (start_active_slot(slot)) {
|
||||
run_active_slot(slot);
|
||||
|
|
@ -1682,21 +1671,15 @@ static int delete_remote_branch(const char *pattern, int force)
|
|||
|
||||
static void run_request_queue(void)
|
||||
{
|
||||
#ifdef USE_CURL_MULTI
|
||||
is_running_queue = 1;
|
||||
fill_active_slots();
|
||||
add_fill_function(NULL, fill_active_slot);
|
||||
#endif
|
||||
do {
|
||||
finish_all_active_slots();
|
||||
#ifdef USE_CURL_MULTI
|
||||
fill_active_slots();
|
||||
#endif
|
||||
} while (request_queue_head && !aborted);
|
||||
|
||||
#ifdef USE_CURL_MULTI
|
||||
is_running_queue = 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
int cmd_main(int argc, const char **argv)
|
||||
|
|
@ -1770,10 +1753,6 @@ int cmd_main(int argc, const char **argv)
|
|||
break;
|
||||
}
|
||||
|
||||
#ifndef USE_CURL_MULTI
|
||||
die("git-push is not available for http/https repository when not compiled with USE_CURL_MULTI");
|
||||
#endif
|
||||
|
||||
if (!repo->url)
|
||||
usage(http_push_usage);
|
||||
|
||||
|
|
@ -1786,9 +1765,7 @@ int cmd_main(int argc, const char **argv)
|
|||
|
||||
http_init(NULL, repo->url, 1);
|
||||
|
||||
#ifdef USE_CURL_MULTI
|
||||
is_running_queue = 0;
|
||||
#endif
|
||||
|
||||
/* Verify DAV compliance/lock support */
|
||||
if (!locking_available()) {
|
||||
|
|
|
|||
|
|
@ -127,7 +127,6 @@ static void release_object_request(struct object_request *obj_req)
|
|||
free(obj_req);
|
||||
}
|
||||
|
||||
#ifdef USE_CURL_MULTI
|
||||
static int fill_active_slot(struct walker *walker)
|
||||
{
|
||||
struct object_request *obj_req;
|
||||
|
|
@ -146,7 +145,6 @@ static int fill_active_slot(struct walker *walker)
|
|||
}
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
static void prefetch(struct walker *walker, unsigned char *sha1)
|
||||
{
|
||||
|
|
@ -163,10 +161,8 @@ static void prefetch(struct walker *walker, unsigned char *sha1)
|
|||
http_is_verbose = walker->get_verbosely;
|
||||
list_add_tail(&newreq->node, &object_queue_head);
|
||||
|
||||
#ifdef USE_CURL_MULTI
|
||||
fill_active_slots();
|
||||
step_active_slots();
|
||||
#endif
|
||||
}
|
||||
|
||||
static int is_alternate_allowed(const char *url)
|
||||
|
|
@ -357,11 +353,9 @@ static void fetch_alternates(struct walker *walker, const char *base)
|
|||
* wait for them to arrive and return to processing this request's
|
||||
* curl message
|
||||
*/
|
||||
#ifdef USE_CURL_MULTI
|
||||
while (cdata->got_alternates == 0) {
|
||||
step_active_slots();
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Nothing to do if they've already been fetched */
|
||||
if (cdata->got_alternates == 1)
|
||||
|
|
@ -384,7 +378,7 @@ static void fetch_alternates(struct walker *walker, const char *base)
|
|||
alt_req.walker = walker;
|
||||
slot->callback_data = &alt_req;
|
||||
|
||||
curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
|
||||
curl_easy_setopt(slot->curl, CURLOPT_WRITEDATA, &buffer);
|
||||
curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
|
||||
curl_easy_setopt(slot->curl, CURLOPT_URL, url.buf);
|
||||
|
||||
|
|
@ -505,12 +499,8 @@ static int fetch_object(struct walker *walker, unsigned char *hash)
|
|||
return 0;
|
||||
}
|
||||
|
||||
#ifdef USE_CURL_MULTI
|
||||
while (obj_req->state == WAITING)
|
||||
step_active_slots();
|
||||
#else
|
||||
start_object_request(walker, obj_req);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* obj_req->req might change when fetching alternates in the callback
|
||||
|
|
@ -623,9 +613,7 @@ struct walker *get_http_walker(const char *url)
|
|||
walker->cleanup = cleanup;
|
||||
walker->data = data;
|
||||
|
||||
#ifdef USE_CURL_MULTI
|
||||
add_fill_function(walker, (int (*)(void *)) fill_active_slot);
|
||||
#endif
|
||||
|
||||
return walker;
|
||||
}
|
||||
|
|
|
|||
169
http.c
169
http.c
|
|
@ -19,28 +19,16 @@
|
|||
static struct trace_key trace_curl = TRACE_KEY_INIT(CURL);
|
||||
static int trace_curl_data = 1;
|
||||
static int trace_curl_redact = 1;
|
||||
#if LIBCURL_VERSION_NUM >= 0x070a08
|
||||
long int git_curl_ipresolve = CURL_IPRESOLVE_WHATEVER;
|
||||
#else
|
||||
long int git_curl_ipresolve;
|
||||
#endif
|
||||
int active_requests;
|
||||
int http_is_verbose;
|
||||
ssize_t http_post_buffer = 16 * LARGE_PACKET_MAX;
|
||||
|
||||
#if LIBCURL_VERSION_NUM >= 0x070a06
|
||||
#define LIBCURL_CAN_HANDLE_AUTH_ANY
|
||||
#endif
|
||||
|
||||
static int min_curl_sessions = 1;
|
||||
static int curl_session_count;
|
||||
#ifdef USE_CURL_MULTI
|
||||
static int max_requests = -1;
|
||||
static CURLM *curlm;
|
||||
#endif
|
||||
#ifndef NO_CURL_EASY_DUPHANDLE
|
||||
static CURL *curl_default;
|
||||
#endif
|
||||
|
||||
#define PREV_BUF_SIZE 4096
|
||||
|
||||
|
|
@ -68,15 +56,9 @@ static struct {
|
|||
{ "tlsv1.3", CURL_SSLVERSION_TLSv1_3 },
|
||||
#endif
|
||||
};
|
||||
#if LIBCURL_VERSION_NUM >= 0x070903
|
||||
static const char *ssl_key;
|
||||
#endif
|
||||
#if LIBCURL_VERSION_NUM >= 0x070908
|
||||
static const char *ssl_capath;
|
||||
#endif
|
||||
#if LIBCURL_VERSION_NUM >= 0x071304
|
||||
static const char *curl_no_proxy;
|
||||
#endif
|
||||
#if LIBCURL_VERSION_NUM >= 0x072c00
|
||||
static const char *ssl_pinnedkey;
|
||||
#endif
|
||||
|
|
@ -101,9 +83,7 @@ static struct {
|
|||
{ "digest", CURLAUTH_DIGEST },
|
||||
{ "negotiate", CURLAUTH_GSSNEGOTIATE },
|
||||
{ "ntlm", CURLAUTH_NTLM },
|
||||
#ifdef LIBCURL_CAN_HANDLE_AUTH_ANY
|
||||
{ "anyauth", CURLAUTH_ANY },
|
||||
#endif
|
||||
/*
|
||||
* CURLAUTH_DIGEST_IE has no corresponding command-line option in
|
||||
* curl(1) and is not included in CURLAUTH_ANY, so we leave it out
|
||||
|
|
@ -133,27 +113,15 @@ static int curl_empty_auth = -1;
|
|||
|
||||
enum http_follow_config http_follow_config = HTTP_FOLLOW_INITIAL;
|
||||
|
||||
#if LIBCURL_VERSION_NUM >= 0x071700
|
||||
/* Use CURLOPT_KEYPASSWD as is */
|
||||
#elif LIBCURL_VERSION_NUM >= 0x070903
|
||||
#define CURLOPT_KEYPASSWD CURLOPT_SSLKEYPASSWD
|
||||
#else
|
||||
#define CURLOPT_KEYPASSWD CURLOPT_SSLCERTPASSWD
|
||||
#endif
|
||||
|
||||
static struct credential cert_auth = CREDENTIAL_INIT;
|
||||
static int ssl_cert_password_required;
|
||||
#ifdef LIBCURL_CAN_HANDLE_AUTH_ANY
|
||||
static unsigned long http_auth_methods = CURLAUTH_ANY;
|
||||
static int http_auth_methods_restricted;
|
||||
/* Modes for which empty_auth cannot actually help us. */
|
||||
static unsigned long empty_auth_useless =
|
||||
CURLAUTH_BASIC
|
||||
#ifdef CURLAUTH_DIGEST_IE
|
||||
| CURLAUTH_DIGEST_IE
|
||||
#endif
|
||||
| CURLAUTH_DIGEST;
|
||||
#endif
|
||||
|
||||
static struct curl_slist *pragma_header;
|
||||
static struct curl_slist *no_pragma_header;
|
||||
|
|
@ -186,7 +154,6 @@ size_t fread_buffer(char *ptr, size_t eltsize, size_t nmemb, void *buffer_)
|
|||
return size / eltsize;
|
||||
}
|
||||
|
||||
#ifndef NO_CURL_IOCTL
|
||||
curlioerr ioctl_buffer(CURL *handle, int cmd, void *clientp)
|
||||
{
|
||||
struct buffer *buffer = clientp;
|
||||
|
|
@ -203,7 +170,6 @@ curlioerr ioctl_buffer(CURL *handle, int cmd, void *clientp)
|
|||
return CURLIOE_UNKNOWNCMD;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
size_t fwrite_buffer(char *ptr, size_t eltsize, size_t nmemb, void *buffer_)
|
||||
{
|
||||
|
|
@ -237,12 +203,8 @@ static void finish_active_slot(struct active_request_slot *slot)
|
|||
if (slot->results != NULL) {
|
||||
slot->results->curl_result = slot->curl_result;
|
||||
slot->results->http_code = slot->http_code;
|
||||
#if LIBCURL_VERSION_NUM >= 0x070a08
|
||||
curl_easy_getinfo(slot->curl, CURLINFO_HTTPAUTH_AVAIL,
|
||||
&slot->results->auth_avail);
|
||||
#else
|
||||
slot->results->auth_avail = 0;
|
||||
#endif
|
||||
|
||||
curl_easy_getinfo(slot->curl, CURLINFO_HTTP_CONNECTCODE,
|
||||
&slot->results->http_connectcode);
|
||||
|
|
@ -255,12 +217,9 @@ static void finish_active_slot(struct active_request_slot *slot)
|
|||
|
||||
static void xmulti_remove_handle(struct active_request_slot *slot)
|
||||
{
|
||||
#ifdef USE_CURL_MULTI
|
||||
curl_multi_remove_handle(curlm, slot->curl);
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef USE_CURL_MULTI
|
||||
static void process_curl_messages(void)
|
||||
{
|
||||
int num_messages;
|
||||
|
|
@ -288,7 +247,6 @@ static void process_curl_messages(void)
|
|||
curl_message = curl_multi_info_read(curlm, &num_messages);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
static int http_options(const char *var, const char *value, void *cb)
|
||||
{
|
||||
|
|
@ -305,14 +263,10 @@ static int http_options(const char *var, const char *value, void *cb)
|
|||
return git_config_string(&ssl_version, var, value);
|
||||
if (!strcmp("http.sslcert", var))
|
||||
return git_config_pathname(&ssl_cert, var, value);
|
||||
#if LIBCURL_VERSION_NUM >= 0x070903
|
||||
if (!strcmp("http.sslkey", var))
|
||||
return git_config_pathname(&ssl_key, var, value);
|
||||
#endif
|
||||
#if LIBCURL_VERSION_NUM >= 0x070908
|
||||
if (!strcmp("http.sslcapath", var))
|
||||
return git_config_pathname(&ssl_capath, var, value);
|
||||
#endif
|
||||
if (!strcmp("http.sslcainfo", var))
|
||||
return git_config_pathname(&ssl_cainfo, var, value);
|
||||
if (!strcmp("http.sslcertpasswordprotected", var)) {
|
||||
|
|
@ -341,18 +295,14 @@ static int http_options(const char *var, const char *value, void *cb)
|
|||
|
||||
if (!strcmp("http.minsessions", var)) {
|
||||
min_curl_sessions = git_config_int(var, value);
|
||||
#ifndef USE_CURL_MULTI
|
||||
if (min_curl_sessions > 1)
|
||||
min_curl_sessions = 1;
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
#ifdef USE_CURL_MULTI
|
||||
if (!strcmp("http.maxrequests", var)) {
|
||||
max_requests = git_config_int(var, value);
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
if (!strcmp("http.lowspeedlimit", var)) {
|
||||
curl_low_speed_limit = (long)git_config_int(var, value);
|
||||
return 0;
|
||||
|
|
@ -461,12 +411,6 @@ static int curl_empty_auth_enabled(void)
|
|||
if (curl_empty_auth >= 0)
|
||||
return curl_empty_auth;
|
||||
|
||||
#ifndef LIBCURL_CAN_HANDLE_AUTH_ANY
|
||||
/*
|
||||
* Our libcurl is too old to do AUTH_ANY in the first place;
|
||||
* just default to turning the feature off.
|
||||
*/
|
||||
#else
|
||||
/*
|
||||
* In the automatic case, kick in the empty-auth
|
||||
* hack as long as we would potentially try some
|
||||
|
|
@ -479,7 +423,6 @@ static int curl_empty_auth_enabled(void)
|
|||
if (http_auth_methods_restricted &&
|
||||
(http_auth_methods & ~empty_auth_useless))
|
||||
return 1;
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -493,24 +436,8 @@ static void init_curl_http_auth(CURL *result)
|
|||
|
||||
credential_fill(&http_auth);
|
||||
|
||||
#if LIBCURL_VERSION_NUM >= 0x071301
|
||||
curl_easy_setopt(result, CURLOPT_USERNAME, http_auth.username);
|
||||
curl_easy_setopt(result, CURLOPT_PASSWORD, http_auth.password);
|
||||
#else
|
||||
{
|
||||
static struct strbuf up = STRBUF_INIT;
|
||||
/*
|
||||
* Note that we assume we only ever have a single set of
|
||||
* credentials in a given program run, so we do not have
|
||||
* to worry about updating this buffer, only setting its
|
||||
* initial value.
|
||||
*/
|
||||
if (!up.len)
|
||||
strbuf_addf(&up, "%s:%s",
|
||||
http_auth.username, http_auth.password);
|
||||
curl_easy_setopt(result, CURLOPT_USERPWD, up.buf);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
/* *var must be free-able */
|
||||
|
|
@ -524,22 +451,10 @@ static void var_override(const char **var, char *value)
|
|||
|
||||
static void set_proxyauth_name_password(CURL *result)
|
||||
{
|
||||
#if LIBCURL_VERSION_NUM >= 0x071301
|
||||
curl_easy_setopt(result, CURLOPT_PROXYUSERNAME,
|
||||
proxy_auth.username);
|
||||
curl_easy_setopt(result, CURLOPT_PROXYPASSWORD,
|
||||
proxy_auth.password);
|
||||
#else
|
||||
struct strbuf s = STRBUF_INIT;
|
||||
|
||||
strbuf_addstr_urlencode(&s, proxy_auth.username,
|
||||
is_rfc3986_unreserved);
|
||||
strbuf_addch(&s, ':');
|
||||
strbuf_addstr_urlencode(&s, proxy_auth.password,
|
||||
is_rfc3986_unreserved);
|
||||
curl_proxyuserpwd = strbuf_detach(&s, NULL);
|
||||
curl_easy_setopt(result, CURLOPT_PROXYUSERPWD, curl_proxyuserpwd);
|
||||
#endif
|
||||
}
|
||||
|
||||
static void init_curl_proxy_auth(CURL *result)
|
||||
|
|
@ -552,7 +467,6 @@ static void init_curl_proxy_auth(CURL *result)
|
|||
|
||||
var_override(&http_proxy_authmethod, getenv("GIT_HTTP_PROXY_AUTHMETHOD"));
|
||||
|
||||
#if LIBCURL_VERSION_NUM >= 0x070a07 /* CURLOPT_PROXYAUTH and CURLAUTH_ANY */
|
||||
if (http_proxy_authmethod) {
|
||||
int i;
|
||||
for (i = 0; i < ARRAY_SIZE(proxy_authmethods); i++) {
|
||||
|
|
@ -570,7 +484,6 @@ static void init_curl_proxy_auth(CURL *result)
|
|||
}
|
||||
else
|
||||
curl_easy_setopt(result, CURLOPT_PROXYAUTH, CURLAUTH_ANY);
|
||||
#endif
|
||||
}
|
||||
|
||||
static int has_cert_password(void)
|
||||
|
|
@ -609,7 +522,7 @@ static void set_curl_keepalive(CURL *c)
|
|||
curl_easy_setopt(c, CURLOPT_TCP_KEEPALIVE, 1);
|
||||
}
|
||||
|
||||
#elif LIBCURL_VERSION_NUM >= 0x071000
|
||||
#else
|
||||
static int sockopt_callback(void *client, curl_socket_t fd, curlsocktype type)
|
||||
{
|
||||
int ka = 1;
|
||||
|
|
@ -630,12 +543,6 @@ static void set_curl_keepalive(CURL *c)
|
|||
{
|
||||
curl_easy_setopt(c, CURLOPT_SOCKOPTFUNCTION, sockopt_callback);
|
||||
}
|
||||
|
||||
#else
|
||||
static void set_curl_keepalive(CURL *c)
|
||||
{
|
||||
/* not supported on older curl versions */
|
||||
}
|
||||
#endif
|
||||
|
||||
static void redact_sensitive_header(struct strbuf *header)
|
||||
|
|
@ -809,7 +716,6 @@ void setup_curl_trace(CURL *handle)
|
|||
curl_easy_setopt(handle, CURLOPT_DEBUGDATA, NULL);
|
||||
}
|
||||
|
||||
#ifdef CURLPROTO_HTTP
|
||||
static long get_curl_allowed_protocols(int from_user)
|
||||
{
|
||||
long allowed_protocols = 0;
|
||||
|
|
@ -825,7 +731,6 @@ static long get_curl_allowed_protocols(int from_user)
|
|||
|
||||
return allowed_protocols;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if LIBCURL_VERSION_NUM >=0x072f00
|
||||
static int get_curl_http_version_opt(const char *version_string, long *opt)
|
||||
|
|
@ -879,12 +784,8 @@ static CURL *get_curl_handle(void)
|
|||
}
|
||||
#endif
|
||||
|
||||
#if LIBCURL_VERSION_NUM >= 0x070907
|
||||
curl_easy_setopt(result, CURLOPT_NETRC, CURL_NETRC_OPTIONAL);
|
||||
#endif
|
||||
#ifdef LIBCURL_CAN_HANDLE_AUTH_ANY
|
||||
curl_easy_setopt(result, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
|
||||
#endif
|
||||
|
||||
#ifdef CURLGSSAPI_DELEGATION_FLAG
|
||||
if (curl_deleg) {
|
||||
|
|
@ -940,14 +841,10 @@ static CURL *get_curl_handle(void)
|
|||
curl_easy_setopt(result, CURLOPT_SSLCERT, ssl_cert);
|
||||
if (has_cert_password())
|
||||
curl_easy_setopt(result, CURLOPT_KEYPASSWD, cert_auth.password);
|
||||
#if LIBCURL_VERSION_NUM >= 0x070903
|
||||
if (ssl_key != NULL)
|
||||
curl_easy_setopt(result, CURLOPT_SSLKEY, ssl_key);
|
||||
#endif
|
||||
#if LIBCURL_VERSION_NUM >= 0x070908
|
||||
if (ssl_capath != NULL)
|
||||
curl_easy_setopt(result, CURLOPT_CAPATH, ssl_capath);
|
||||
#endif
|
||||
#if LIBCURL_VERSION_NUM >= 0x072c00
|
||||
if (ssl_pinnedkey != NULL)
|
||||
curl_easy_setopt(result, CURLOPT_PINNEDPUBLICKEY, ssl_pinnedkey);
|
||||
|
|
@ -975,19 +872,11 @@ static CURL *get_curl_handle(void)
|
|||
}
|
||||
|
||||
curl_easy_setopt(result, CURLOPT_MAXREDIRS, 20);
|
||||
#if LIBCURL_VERSION_NUM >= 0x071301
|
||||
curl_easy_setopt(result, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
|
||||
#elif LIBCURL_VERSION_NUM >= 0x071101
|
||||
curl_easy_setopt(result, CURLOPT_POST301, 1);
|
||||
#endif
|
||||
#ifdef CURLPROTO_HTTP
|
||||
curl_easy_setopt(result, CURLOPT_REDIR_PROTOCOLS,
|
||||
get_curl_allowed_protocols(0));
|
||||
curl_easy_setopt(result, CURLOPT_PROTOCOLS,
|
||||
get_curl_allowed_protocols(-1));
|
||||
#else
|
||||
warning(_("Protocol restrictions not supported with cURL < 7.19.4"));
|
||||
#endif
|
||||
if (getenv("GIT_CURL_VERBOSE"))
|
||||
http_trace_curl_no_data();
|
||||
setup_curl_trace(result);
|
||||
|
|
@ -1002,10 +891,8 @@ static CURL *get_curl_handle(void)
|
|||
if (curl_ftp_no_epsv)
|
||||
curl_easy_setopt(result, CURLOPT_FTP_USE_EPSV, 0);
|
||||
|
||||
#ifdef CURLOPT_USE_SSL
|
||||
if (curl_ssl_try)
|
||||
curl_easy_setopt(result, CURLOPT_USE_SSL, CURLUSESSL_TRY);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* CURL also examines these variables as a fallback; but we need to query
|
||||
|
|
@ -1081,11 +968,9 @@ static CURL *get_curl_handle(void)
|
|||
die("Invalid proxy URL '%s'", curl_http_proxy);
|
||||
|
||||
curl_easy_setopt(result, CURLOPT_PROXY, proxy_auth.host);
|
||||
#if LIBCURL_VERSION_NUM >= 0x071304
|
||||
var_override(&curl_no_proxy, getenv("NO_PROXY"));
|
||||
var_override(&curl_no_proxy, getenv("no_proxy"));
|
||||
curl_easy_setopt(result, CURLOPT_NOPROXY, curl_no_proxy);
|
||||
#endif
|
||||
}
|
||||
init_curl_proxy_auth(result);
|
||||
|
||||
|
|
@ -1164,7 +1049,6 @@ void http_init(struct remote *remote, const char *url, int proactive_auth)
|
|||
no_pragma_header = curl_slist_append(http_copy_default_headers(),
|
||||
"Pragma:");
|
||||
|
||||
#ifdef USE_CURL_MULTI
|
||||
{
|
||||
char *http_max_requests = getenv("GIT_HTTP_MAX_REQUESTS");
|
||||
if (http_max_requests != NULL)
|
||||
|
|
@ -1174,18 +1058,13 @@ void http_init(struct remote *remote, const char *url, int proactive_auth)
|
|||
curlm = curl_multi_init();
|
||||
if (!curlm)
|
||||
die("curl_multi_init failed");
|
||||
#endif
|
||||
|
||||
if (getenv("GIT_SSL_NO_VERIFY"))
|
||||
curl_ssl_verify = 0;
|
||||
|
||||
set_from_env(&ssl_cert, "GIT_SSL_CERT");
|
||||
#if LIBCURL_VERSION_NUM >= 0x070903
|
||||
set_from_env(&ssl_key, "GIT_SSL_KEY");
|
||||
#endif
|
||||
#if LIBCURL_VERSION_NUM >= 0x070908
|
||||
set_from_env(&ssl_capath, "GIT_SSL_CAPATH");
|
||||
#endif
|
||||
set_from_env(&ssl_cainfo, "GIT_SSL_CAINFO");
|
||||
|
||||
set_from_env(&user_agent, "GIT_HTTP_USER_AGENT");
|
||||
|
|
@ -1201,10 +1080,8 @@ void http_init(struct remote *remote, const char *url, int proactive_auth)
|
|||
curl_ssl_verify = 1;
|
||||
|
||||
curl_session_count = 0;
|
||||
#ifdef USE_CURL_MULTI
|
||||
if (max_requests < 1)
|
||||
max_requests = DEFAULT_MAX_REQUESTS;
|
||||
#endif
|
||||
|
||||
set_from_env(&http_proxy_ssl_cert, "GIT_PROXY_SSL_CERT");
|
||||
set_from_env(&http_proxy_ssl_key, "GIT_PROXY_SSL_KEY");
|
||||
|
|
@ -1224,9 +1101,7 @@ void http_init(struct remote *remote, const char *url, int proactive_auth)
|
|||
ssl_cert_password_required = 1;
|
||||
}
|
||||
|
||||
#ifndef NO_CURL_EASY_DUPHANDLE
|
||||
curl_default = get_curl_handle();
|
||||
#endif
|
||||
}
|
||||
|
||||
void http_cleanup(void)
|
||||
|
|
@ -1244,13 +1119,9 @@ void http_cleanup(void)
|
|||
}
|
||||
active_queue_head = NULL;
|
||||
|
||||
#ifndef NO_CURL_EASY_DUPHANDLE
|
||||
curl_easy_cleanup(curl_default);
|
||||
#endif
|
||||
|
||||
#ifdef USE_CURL_MULTI
|
||||
curl_multi_cleanup(curlm);
|
||||
#endif
|
||||
curl_global_cleanup();
|
||||
|
||||
string_list_clear(&extra_http_headers, 0);
|
||||
|
|
@ -1297,7 +1168,6 @@ struct active_request_slot *get_active_slot(void)
|
|||
struct active_request_slot *slot = active_queue_head;
|
||||
struct active_request_slot *newslot;
|
||||
|
||||
#ifdef USE_CURL_MULTI
|
||||
int num_transfers;
|
||||
|
||||
/* Wait for a slot to open up if the queue is full */
|
||||
|
|
@ -1306,7 +1176,6 @@ struct active_request_slot *get_active_slot(void)
|
|||
if (num_transfers < active_requests)
|
||||
process_curl_messages();
|
||||
}
|
||||
#endif
|
||||
|
||||
while (slot != NULL && slot->in_use)
|
||||
slot = slot->next;
|
||||
|
|
@ -1329,11 +1198,7 @@ struct active_request_slot *get_active_slot(void)
|
|||
}
|
||||
|
||||
if (slot->curl == NULL) {
|
||||
#ifdef NO_CURL_EASY_DUPHANDLE
|
||||
slot->curl = get_curl_handle();
|
||||
#else
|
||||
slot->curl = curl_easy_duphandle(curl_default);
|
||||
#endif
|
||||
curl_session_count++;
|
||||
}
|
||||
|
||||
|
|
@ -1367,12 +1232,8 @@ struct active_request_slot *get_active_slot(void)
|
|||
else
|
||||
curl_easy_setopt(slot->curl, CURLOPT_FOLLOWLOCATION, 0);
|
||||
|
||||
#if LIBCURL_VERSION_NUM >= 0x070a08
|
||||
curl_easy_setopt(slot->curl, CURLOPT_IPRESOLVE, git_curl_ipresolve);
|
||||
#endif
|
||||
#ifdef LIBCURL_CAN_HANDLE_AUTH_ANY
|
||||
curl_easy_setopt(slot->curl, CURLOPT_HTTPAUTH, http_auth_methods);
|
||||
#endif
|
||||
if (http_auth.password || curl_empty_auth_enabled())
|
||||
init_curl_http_auth(slot->curl);
|
||||
|
||||
|
|
@ -1381,7 +1242,6 @@ struct active_request_slot *get_active_slot(void)
|
|||
|
||||
int start_active_slot(struct active_request_slot *slot)
|
||||
{
|
||||
#ifdef USE_CURL_MULTI
|
||||
CURLMcode curlm_result = curl_multi_add_handle(curlm, slot->curl);
|
||||
int num_transfers;
|
||||
|
||||
|
|
@ -1399,11 +1259,9 @@ int start_active_slot(struct active_request_slot *slot)
|
|||
* something.
|
||||
*/
|
||||
curl_multi_perform(curlm, &num_transfers);
|
||||
#endif
|
||||
return 1;
|
||||
}
|
||||
|
||||
#ifdef USE_CURL_MULTI
|
||||
struct fill_chain {
|
||||
void *data;
|
||||
int (*fill)(void *);
|
||||
|
|
@ -1462,11 +1320,9 @@ void step_active_slots(void)
|
|||
fill_active_slots();
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
void run_active_slot(struct active_request_slot *slot)
|
||||
{
|
||||
#ifdef USE_CURL_MULTI
|
||||
fd_set readfds;
|
||||
fd_set writefds;
|
||||
fd_set excfds;
|
||||
|
|
@ -1479,7 +1335,6 @@ void run_active_slot(struct active_request_slot *slot)
|
|||
step_active_slots();
|
||||
|
||||
if (slot->in_use) {
|
||||
#if LIBCURL_VERSION_NUM >= 0x070f04
|
||||
long curl_timeout;
|
||||
curl_multi_timeout(curlm, &curl_timeout);
|
||||
if (curl_timeout == 0) {
|
||||
|
|
@ -1491,10 +1346,6 @@ void run_active_slot(struct active_request_slot *slot)
|
|||
select_timeout.tv_sec = curl_timeout / 1000;
|
||||
select_timeout.tv_usec = (curl_timeout % 1000) * 1000;
|
||||
}
|
||||
#else
|
||||
select_timeout.tv_sec = 0;
|
||||
select_timeout.tv_usec = 50000;
|
||||
#endif
|
||||
|
||||
max_fd = -1;
|
||||
FD_ZERO(&readfds);
|
||||
|
|
@ -1517,12 +1368,6 @@ void run_active_slot(struct active_request_slot *slot)
|
|||
select(max_fd+1, &readfds, &writefds, &excfds, &select_timeout);
|
||||
}
|
||||
}
|
||||
#else
|
||||
while (slot->in_use) {
|
||||
slot->curl_result = curl_easy_perform(slot->curl);
|
||||
finish_active_slot(slot);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
static void release_active_slot(struct active_request_slot *slot)
|
||||
|
|
@ -1536,9 +1381,7 @@ static void release_active_slot(struct active_request_slot *slot)
|
|||
curl_session_count--;
|
||||
}
|
||||
}
|
||||
#ifdef USE_CURL_MULTI
|
||||
fill_active_slots();
|
||||
#endif
|
||||
}
|
||||
|
||||
void finish_all_active_slots(void)
|
||||
|
|
@ -1654,24 +1497,20 @@ static int handle_curl_result(struct slot_results *results)
|
|||
credential_reject(&http_auth);
|
||||
return HTTP_NOAUTH;
|
||||
} else {
|
||||
#ifdef LIBCURL_CAN_HANDLE_AUTH_ANY
|
||||
http_auth_methods &= ~CURLAUTH_GSSNEGOTIATE;
|
||||
if (results->auth_avail) {
|
||||
http_auth_methods &= results->auth_avail;
|
||||
http_auth_methods_restricted = 1;
|
||||
}
|
||||
#endif
|
||||
return HTTP_REAUTH;
|
||||
}
|
||||
} else {
|
||||
if (results->http_connectcode == 407)
|
||||
credential_reject(&proxy_auth);
|
||||
#if LIBCURL_VERSION_NUM >= 0x070c00
|
||||
if (!curl_errorstr[0])
|
||||
strlcpy(curl_errorstr,
|
||||
curl_easy_strerror(results->curl_result),
|
||||
sizeof(curl_errorstr));
|
||||
#endif
|
||||
return HTTP_ERROR;
|
||||
}
|
||||
}
|
||||
|
|
@ -1930,7 +1769,7 @@ static int http_request(const char *url,
|
|||
curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 1);
|
||||
} else {
|
||||
curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 0);
|
||||
curl_easy_setopt(slot->curl, CURLOPT_FILE, result);
|
||||
curl_easy_setopt(slot->curl, CURLOPT_WRITEDATA, result);
|
||||
|
||||
if (target == HTTP_REQUEST_FILE) {
|
||||
off_t posn = ftello(result);
|
||||
|
|
@ -2347,7 +2186,7 @@ struct http_pack_request *new_direct_http_pack_request(
|
|||
}
|
||||
|
||||
preq->slot = get_active_slot();
|
||||
curl_easy_setopt(preq->slot->curl, CURLOPT_FILE, preq->packfile);
|
||||
curl_easy_setopt(preq->slot->curl, CURLOPT_WRITEDATA, preq->packfile);
|
||||
curl_easy_setopt(preq->slot->curl, CURLOPT_WRITEFUNCTION, fwrite);
|
||||
curl_easy_setopt(preq->slot->curl, CURLOPT_URL, preq->url);
|
||||
curl_easy_setopt(preq->slot->curl, CURLOPT_HTTPHEADER,
|
||||
|
|
@ -2518,7 +2357,7 @@ struct http_object_request *new_http_object_request(const char *base_url,
|
|||
|
||||
freq->slot = get_active_slot();
|
||||
|
||||
curl_easy_setopt(freq->slot->curl, CURLOPT_FILE, freq);
|
||||
curl_easy_setopt(freq->slot->curl, CURLOPT_WRITEDATA, freq);
|
||||
curl_easy_setopt(freq->slot->curl, CURLOPT_FAILONERROR, 0);
|
||||
curl_easy_setopt(freq->slot->curl, CURLOPT_WRITEFUNCTION, fwrite_sha1_file);
|
||||
curl_easy_setopt(freq->slot->curl, CURLOPT_ERRORBUFFER, freq->errorstr);
|
||||
|
|
|
|||
46
http.h
46
http.h
|
|
@ -10,49 +10,7 @@
|
|||
#include "remote.h"
|
||||
#include "url.h"
|
||||
|
||||
/*
|
||||
* We detect based on the cURL version if multi-transfer is
|
||||
* usable in this implementation and define this symbol accordingly.
|
||||
* This shouldn't be set by the Makefile or by the user (e.g. via CFLAGS).
|
||||
*/
|
||||
#undef USE_CURL_MULTI
|
||||
|
||||
#if LIBCURL_VERSION_NUM >= 0x071000
|
||||
#define USE_CURL_MULTI
|
||||
#define DEFAULT_MAX_REQUESTS 5
|
||||
#endif
|
||||
|
||||
#if LIBCURL_VERSION_NUM < 0x070704
|
||||
#define curl_global_cleanup() do { /* nothing */ } while (0)
|
||||
#endif
|
||||
|
||||
#if LIBCURL_VERSION_NUM < 0x070800
|
||||
#define curl_global_init(a) do { /* nothing */ } while (0)
|
||||
#elif LIBCURL_VERSION_NUM >= 0x070c00
|
||||
#define curl_global_init(a) curl_global_init_mem(a, xmalloc, free, \
|
||||
xrealloc, xstrdup, xcalloc)
|
||||
#endif
|
||||
|
||||
#if (LIBCURL_VERSION_NUM < 0x070c04) || (LIBCURL_VERSION_NUM == 0x071000)
|
||||
#define NO_CURL_EASY_DUPHANDLE
|
||||
#endif
|
||||
|
||||
#if LIBCURL_VERSION_NUM < 0x070a03
|
||||
#define CURLE_HTTP_RETURNED_ERROR CURLE_HTTP_NOT_FOUND
|
||||
#endif
|
||||
|
||||
#if LIBCURL_VERSION_NUM < 0x070c03
|
||||
#define NO_CURL_IOCTL
|
||||
#endif
|
||||
|
||||
/*
|
||||
* CURLOPT_USE_SSL was known as CURLOPT_FTP_SSL up to 7.16.4,
|
||||
* and the constants were known as CURLFTPSSL_*
|
||||
*/
|
||||
#if !defined(CURLOPT_USE_SSL) && defined(CURLOPT_FTP_SSL)
|
||||
#define CURLOPT_USE_SSL CURLOPT_FTP_SSL
|
||||
#define CURLUSESSL_TRY CURLFTPSSL_TRY
|
||||
#endif
|
||||
|
||||
struct slot_results {
|
||||
CURLcode curl_result;
|
||||
|
|
@ -82,9 +40,7 @@ struct buffer {
|
|||
size_t fread_buffer(char *ptr, size_t eltsize, size_t nmemb, void *strbuf);
|
||||
size_t fwrite_buffer(char *ptr, size_t eltsize, size_t nmemb, void *strbuf);
|
||||
size_t fwrite_null(char *ptr, size_t eltsize, size_t nmemb, void *strbuf);
|
||||
#ifndef NO_CURL_IOCTL
|
||||
curlioerr ioctl_buffer(CURL *handle, int cmd, void *clientp);
|
||||
#endif
|
||||
|
||||
/* Slot lifecycle functions */
|
||||
struct active_request_slot *get_active_slot(void);
|
||||
|
|
@ -101,11 +57,9 @@ void finish_all_active_slots(void);
|
|||
int run_one_slot(struct active_request_slot *slot,
|
||||
struct slot_results *results);
|
||||
|
||||
#ifdef USE_CURL_MULTI
|
||||
void fill_active_slots(void);
|
||||
void add_fill_function(void *data, int (*fill)(void *));
|
||||
void step_active_slots(void);
|
||||
#endif
|
||||
|
||||
void http_init(struct remote *remote, const char *url,
|
||||
int proactive_auth);
|
||||
|
|
|
|||
|
|
@ -1517,11 +1517,7 @@ static int curl_append_msgs_to_imap(struct imap_server_conf *server,
|
|||
if (cred.username) {
|
||||
if (res == CURLE_OK)
|
||||
credential_approve(&cred);
|
||||
#if LIBCURL_VERSION_NUM >= 0x070d01
|
||||
else if (res == CURLE_LOGIN_DENIED)
|
||||
#else
|
||||
else
|
||||
#endif
|
||||
credential_reject(&cred);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -185,8 +185,6 @@ static int set_option(const char *name, const char *value)
|
|||
strbuf_detach(&unquoted, NULL));
|
||||
}
|
||||
return 0;
|
||||
|
||||
#if LIBCURL_VERSION_NUM >= 0x070a08
|
||||
} else if (!strcmp(name, "family")) {
|
||||
if (!strcmp(value, "ipv4"))
|
||||
git_curl_ipresolve = CURL_IPRESOLVE_V4;
|
||||
|
|
@ -197,7 +195,6 @@ static int set_option(const char *name, const char *value)
|
|||
else
|
||||
return -1;
|
||||
return 0;
|
||||
#endif /* LIBCURL_VERSION_NUM >= 0x070a08 */
|
||||
} else if (!strcmp(name, "from-promisor")) {
|
||||
options.from_promisor = 1;
|
||||
return 0;
|
||||
|
|
@ -709,7 +706,6 @@ static size_t rpc_out(void *ptr, size_t eltsize,
|
|||
return avail;
|
||||
}
|
||||
|
||||
#ifndef NO_CURL_IOCTL
|
||||
static curlioerr rpc_ioctl(CURL *handle, int cmd, void *clientp)
|
||||
{
|
||||
struct rpc_state *rpc = clientp;
|
||||
|
|
@ -730,7 +726,6 @@ static curlioerr rpc_ioctl(CURL *handle, int cmd, void *clientp)
|
|||
return CURLIOE_UNKNOWNCMD;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
struct check_pktline_state {
|
||||
char len_buf[4];
|
||||
|
|
@ -858,7 +853,7 @@ static int probe_rpc(struct rpc_state *rpc, struct slot_results *results)
|
|||
curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDSIZE, 4);
|
||||
curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, headers);
|
||||
curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
|
||||
curl_easy_setopt(slot->curl, CURLOPT_FILE, &buf);
|
||||
curl_easy_setopt(slot->curl, CURLOPT_WRITEDATA, &buf);
|
||||
|
||||
err = run_slot(slot, results);
|
||||
|
||||
|
|
@ -949,10 +944,8 @@ static int post_rpc(struct rpc_state *rpc, int stateless_connect, int flush_rece
|
|||
rpc->initial_buffer = 1;
|
||||
curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, rpc_out);
|
||||
curl_easy_setopt(slot->curl, CURLOPT_INFILE, rpc);
|
||||
#ifndef NO_CURL_IOCTL
|
||||
curl_easy_setopt(slot->curl, CURLOPT_IOCTLFUNCTION, rpc_ioctl);
|
||||
curl_easy_setopt(slot->curl, CURLOPT_IOCTLDATA, rpc);
|
||||
#endif
|
||||
if (options.verbosity > 1) {
|
||||
fprintf(stderr, "POST %s (chunked)\n", rpc->service_name);
|
||||
fflush(stderr);
|
||||
|
|
@ -1023,7 +1016,7 @@ static int post_rpc(struct rpc_state *rpc, int stateless_connect, int flush_rece
|
|||
rpc_in_data.slot = slot;
|
||||
rpc_in_data.check_pktline = stateless_connect;
|
||||
memset(&rpc_in_data.pktline_state, 0, sizeof(rpc_in_data.pktline_state));
|
||||
curl_easy_setopt(slot->curl, CURLOPT_FILE, &rpc_in_data);
|
||||
curl_easy_setopt(slot->curl, CURLOPT_WRITEDATA, &rpc_in_data);
|
||||
curl_easy_setopt(slot->curl, CURLOPT_FAILONERROR, 0);
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue