kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

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
maint
Junio C Hamano 2021-08-24 15:32:36 -07:00
parent 2f71366878 8dda4cbdf2
commit e48a623dea
6 changed files with 10 additions and 263 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
http-push.c
View File

@ -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_INFILE, buffer);
curl_easy_setopt(curl, CURLOPT_INFILESIZE, buffer->buf.len); curl_easy_setopt(curl, CURLOPT_INFILESIZE, buffer->buf.len);
curl_easy_setopt(curl, CURLOPT_READFUNCTION, fread_buffer); 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_IOCTLFUNCTION, ioctl_buffer);
curl_easy_setopt(curl, CURLOPT_IOCTLDATA, buffer); curl_easy_setopt(curl, CURLOPT_IOCTLDATA, buffer);
#endif
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_fn); curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_fn);
curl_easy_setopt(curl, CURLOPT_NOBODY, 0); curl_easy_setopt(curl, CURLOPT_NOBODY, 0);
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, custom_req); curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, custom_req);
@ -249,8 +247,6 @@ static void process_response(void *callback_data)
finish_request(request); finish_request(request);
} }


#ifdef USE_CURL_MULTI

static void start_fetch_loose(struct transfer_request *request) static void start_fetch_loose(struct transfer_request *request)
{ {
struct active_request_slot *slot; struct active_request_slot *slot;
@ -299,7 +295,6 @@ static void start_mkcol(struct transfer_request *request)
FREE_AND_NULL(request->url); FREE_AND_NULL(request->url);
} }
} }
#endif


static void start_fetch_packed(struct transfer_request *request) 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 is_running_queue;
static int fill_active_slot(void *unused) static int fill_active_slot(void *unused)
{ {
@ -629,7 +623,6 @@ static int fill_active_slot(void *unused)
} }
return 0; return 0;
} }
#endif


static void get_remote_object_list(unsigned char parent); 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->next = request_queue_head;
request_queue_head = request; request_queue_head = request;


#ifdef USE_CURL_MULTI
fill_active_slots(); fill_active_slots();
step_active_slots(); step_active_slots();
#endif
} }


static int add_send_request(struct object *obj, struct remote_lock *lock) 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->next = request_queue_head;
request_queue_head = request; request_queue_head = request;


#ifdef USE_CURL_MULTI
fill_active_slots(); fill_active_slots();
step_active_slots(); step_active_slots();
#endif


return 1; return 1;
} }
@ -894,7 +883,7 @@ static struct remote_lock *lock_remote(const char *path, long timeout)
slot->results = &results; slot->results = &results;
curl_setup_http(slot->curl, url, DAV_LOCK, &out_buffer, fwrite_buffer); 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_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); CALLOC_ARRAY(lock, 1);
lock->timeout = -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, curl_setup_http(slot->curl, url, DAV_PROPFIND,
&out_buffer, fwrite_buffer); &out_buffer, fwrite_buffer);
curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers); 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)) { if (start_active_slot(slot)) {
run_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, curl_setup_http(slot->curl, repo->url, DAV_PROPFIND,
&out_buffer, fwrite_buffer); &out_buffer, fwrite_buffer);
curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers); 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)) { if (start_active_slot(slot)) {
run_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) static void run_request_queue(void)
{ {
#ifdef USE_CURL_MULTI
is_running_queue = 1; is_running_queue = 1;
fill_active_slots(); fill_active_slots();
add_fill_function(NULL, fill_active_slot); add_fill_function(NULL, fill_active_slot);
#endif
do { do {
finish_all_active_slots(); finish_all_active_slots();
#ifdef USE_CURL_MULTI
fill_active_slots(); fill_active_slots();
#endif
} while (request_queue_head && !aborted); } while (request_queue_head && !aborted);


#ifdef USE_CURL_MULTI
is_running_queue = 0; is_running_queue = 0;
#endif
} }


int cmd_main(int argc, const char **argv) int cmd_main(int argc, const char **argv)
@ -1770,10 +1753,6 @@ int cmd_main(int argc, const char **argv)
break; 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) if (!repo->url)
usage(http_push_usage); usage(http_push_usage);


@ -1786,9 +1765,7 @@ int cmd_main(int argc, const char **argv)


http_init(NULL, repo->url, 1); http_init(NULL, repo->url, 1);


#ifdef USE_CURL_MULTI
is_running_queue = 0; is_running_queue = 0;
#endif


/* Verify DAV compliance/lock support */ /* Verify DAV compliance/lock support */
if (!locking_available()) { if (!locking_available()) {

14
http-walker.c
View File

@ -127,7 +127,6 @@ static void release_object_request(struct object_request *obj_req)
free(obj_req); free(obj_req);
} }


#ifdef USE_CURL_MULTI
static int fill_active_slot(struct walker *walker) static int fill_active_slot(struct walker *walker)
{ {
struct object_request *obj_req; struct object_request *obj_req;
@ -146,7 +145,6 @@ static int fill_active_slot(struct walker *walker)
} }
return 0; return 0;
} }
#endif


static void prefetch(struct walker *walker, unsigned char *sha1) 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; http_is_verbose = walker->get_verbosely;
list_add_tail(&newreq->node, &object_queue_head); list_add_tail(&newreq->node, &object_queue_head);


#ifdef USE_CURL_MULTI
fill_active_slots(); fill_active_slots();
step_active_slots(); step_active_slots();
#endif
} }


static int is_alternate_allowed(const char *url) 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 * wait for them to arrive and return to processing this request's
* curl message * curl message
*/ */
#ifdef USE_CURL_MULTI
while (cdata->got_alternates == 0) { while (cdata->got_alternates == 0) {
step_active_slots(); step_active_slots();
} }
#endif


/* Nothing to do if they've already been fetched */ /* Nothing to do if they've already been fetched */
if (cdata->got_alternates == 1) if (cdata->got_alternates == 1)
@ -384,7 +378,7 @@ static void fetch_alternates(struct walker *walker, const char *base)
alt_req.walker = walker; alt_req.walker = walker;
slot->callback_data = &alt_req; 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_WRITEFUNCTION, fwrite_buffer);
curl_easy_setopt(slot->curl, CURLOPT_URL, url.buf); 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; return 0;
} }


#ifdef USE_CURL_MULTI
while (obj_req->state == WAITING) while (obj_req->state == WAITING)
step_active_slots(); step_active_slots();
#else
start_object_request(walker, obj_req);
#endif


/* /*
* obj_req->req might change when fetching alternates in the callback * 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->cleanup = cleanup;
walker->data = data; walker->data = data;


#ifdef USE_CURL_MULTI
add_fill_function(walker, (int (*)(void *)) fill_active_slot); add_fill_function(walker, (int (*)(void *)) fill_active_slot);
#endif


return walker; return walker;
} }

169
http.c
View File

@ -19,28 +19,16 @@
static struct trace_key trace_curl = TRACE_KEY_INIT(CURL); static struct trace_key trace_curl = TRACE_KEY_INIT(CURL);
static int trace_curl_data = 1; static int trace_curl_data = 1;
static int trace_curl_redact = 1; static int trace_curl_redact = 1;
#if LIBCURL_VERSION_NUM >= 0x070a08
long int git_curl_ipresolve = CURL_IPRESOLVE_WHATEVER; long int git_curl_ipresolve = CURL_IPRESOLVE_WHATEVER;
#else
long int git_curl_ipresolve;
#endif
int active_requests; int active_requests;
int http_is_verbose; int http_is_verbose;
ssize_t http_post_buffer = 16 * LARGE_PACKET_MAX; 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 min_curl_sessions = 1;
static int curl_session_count; static int curl_session_count;
#ifdef USE_CURL_MULTI
static int max_requests = -1; static int max_requests = -1;
static CURLM *curlm; static CURLM *curlm;
#endif
#ifndef NO_CURL_EASY_DUPHANDLE
static CURL *curl_default; static CURL *curl_default;
#endif


#define PREV_BUF_SIZE 4096 #define PREV_BUF_SIZE 4096


@ -68,15 +56,9 @@ static struct {
{ "tlsv1.3", CURL_SSLVERSION_TLSv1_3 }, { "tlsv1.3", CURL_SSLVERSION_TLSv1_3 },
#endif #endif
}; };
#if LIBCURL_VERSION_NUM >= 0x070903
static const char *ssl_key; static const char *ssl_key;
#endif
#if LIBCURL_VERSION_NUM >= 0x070908
static const char *ssl_capath; static const char *ssl_capath;
#endif
#if LIBCURL_VERSION_NUM >= 0x071304
static const char *curl_no_proxy; static const char *curl_no_proxy;
#endif
#if LIBCURL_VERSION_NUM >= 0x072c00 #if LIBCURL_VERSION_NUM >= 0x072c00
static const char *ssl_pinnedkey; static const char *ssl_pinnedkey;
#endif #endif
@ -101,9 +83,7 @@ static struct {
{ "digest", CURLAUTH_DIGEST }, { "digest", CURLAUTH_DIGEST },
{ "negotiate", CURLAUTH_GSSNEGOTIATE }, { "negotiate", CURLAUTH_GSSNEGOTIATE },
{ "ntlm", CURLAUTH_NTLM }, { "ntlm", CURLAUTH_NTLM },
#ifdef LIBCURL_CAN_HANDLE_AUTH_ANY
{ "anyauth", CURLAUTH_ANY }, { "anyauth", CURLAUTH_ANY },
#endif
/* /*
* CURLAUTH_DIGEST_IE has no corresponding command-line option in * CURLAUTH_DIGEST_IE has no corresponding command-line option in
* curl(1) and is not included in CURLAUTH_ANY, so we leave it out * 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; 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 struct credential cert_auth = CREDENTIAL_INIT;
static int ssl_cert_password_required; static int ssl_cert_password_required;
#ifdef LIBCURL_CAN_HANDLE_AUTH_ANY
static unsigned long http_auth_methods = CURLAUTH_ANY; static unsigned long http_auth_methods = CURLAUTH_ANY;
static int http_auth_methods_restricted; static int http_auth_methods_restricted;
/* Modes for which empty_auth cannot actually help us. */ /* Modes for which empty_auth cannot actually help us. */
static unsigned long empty_auth_useless = static unsigned long empty_auth_useless =
CURLAUTH_BASIC CURLAUTH_BASIC
#ifdef CURLAUTH_DIGEST_IE
| CURLAUTH_DIGEST_IE | CURLAUTH_DIGEST_IE
#endif
| CURLAUTH_DIGEST; | CURLAUTH_DIGEST;
#endif


static struct curl_slist *pragma_header; static struct curl_slist *pragma_header;
static struct curl_slist *no_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; return size / eltsize;
} }


#ifndef NO_CURL_IOCTL
curlioerr ioctl_buffer(CURL *handle, int cmd, void *clientp) curlioerr ioctl_buffer(CURL *handle, int cmd, void *clientp)
{ {
struct buffer *buffer = clientp; struct buffer *buffer = clientp;
@ -203,7 +170,6 @@ curlioerr ioctl_buffer(CURL *handle, int cmd, void *clientp)
return CURLIOE_UNKNOWNCMD; return CURLIOE_UNKNOWNCMD;
} }
} }
#endif


size_t fwrite_buffer(char *ptr, size_t eltsize, size_t nmemb, void *buffer_) 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) { if (slot->results != NULL) {
slot->results->curl_result = slot->curl_result; slot->results->curl_result = slot->curl_result;
slot->results->http_code = slot->http_code; slot->results->http_code = slot->http_code;
#if LIBCURL_VERSION_NUM >= 0x070a08
curl_easy_getinfo(slot->curl, CURLINFO_HTTPAUTH_AVAIL, curl_easy_getinfo(slot->curl, CURLINFO_HTTPAUTH_AVAIL,
&slot->results->auth_avail); &slot->results->auth_avail);
#else
slot->results->auth_avail = 0;
#endif


curl_easy_getinfo(slot->curl, CURLINFO_HTTP_CONNECTCODE, curl_easy_getinfo(slot->curl, CURLINFO_HTTP_CONNECTCODE,
&slot->results->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) static void xmulti_remove_handle(struct active_request_slot *slot)
{ {
#ifdef USE_CURL_MULTI
curl_multi_remove_handle(curlm, slot->curl); curl_multi_remove_handle(curlm, slot->curl);
#endif
} }


#ifdef USE_CURL_MULTI
static void process_curl_messages(void) static void process_curl_messages(void)
{ {
int num_messages; int num_messages;
@ -288,7 +247,6 @@ static void process_curl_messages(void)
curl_message = curl_multi_info_read(curlm, &num_messages); curl_message = curl_multi_info_read(curlm, &num_messages);
} }
} }
#endif


static int http_options(const char *var, const char *value, void *cb) 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); return git_config_string(&ssl_version, var, value);
if (!strcmp("http.sslcert", var)) if (!strcmp("http.sslcert", var))
return git_config_pathname(&ssl_cert, var, value); return git_config_pathname(&ssl_cert, var, value);
#if LIBCURL_VERSION_NUM >= 0x070903
if (!strcmp("http.sslkey", var)) if (!strcmp("http.sslkey", var))
return git_config_pathname(&ssl_key, var, value); return git_config_pathname(&ssl_key, var, value);
#endif
#if LIBCURL_VERSION_NUM >= 0x070908
if (!strcmp("http.sslcapath", var)) if (!strcmp("http.sslcapath", var))
return git_config_pathname(&ssl_capath, var, value); return git_config_pathname(&ssl_capath, var, value);
#endif
if (!strcmp("http.sslcainfo", var)) if (!strcmp("http.sslcainfo", var))
return git_config_pathname(&ssl_cainfo, var, value); return git_config_pathname(&ssl_cainfo, var, value);
if (!strcmp("http.sslcertpasswordprotected", var)) { 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)) { if (!strcmp("http.minsessions", var)) {
min_curl_sessions = git_config_int(var, value); min_curl_sessions = git_config_int(var, value);
#ifndef USE_CURL_MULTI
if (min_curl_sessions > 1) if (min_curl_sessions > 1)
min_curl_sessions = 1; min_curl_sessions = 1;
#endif
return 0; return 0;
} }
#ifdef USE_CURL_MULTI
if (!strcmp("http.maxrequests", var)) { if (!strcmp("http.maxrequests", var)) {
max_requests = git_config_int(var, value); max_requests = git_config_int(var, value);
return 0; return 0;
} }
#endif
if (!strcmp("http.lowspeedlimit", var)) { if (!strcmp("http.lowspeedlimit", var)) {
curl_low_speed_limit = (long)git_config_int(var, value); curl_low_speed_limit = (long)git_config_int(var, value);
return 0; return 0;
@ -461,12 +411,6 @@ static int curl_empty_auth_enabled(void)
if (curl_empty_auth >= 0) if (curl_empty_auth >= 0)
return curl_empty_auth; 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 * In the automatic case, kick in the empty-auth
* hack as long as we would potentially try some * 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 && if (http_auth_methods_restricted &&
(http_auth_methods & ~empty_auth_useless)) (http_auth_methods & ~empty_auth_useless))
return 1; return 1;
#endif
return 0; return 0;
} }


@ -493,24 +436,8 @@ static void init_curl_http_auth(CURL *result)


credential_fill(&http_auth); credential_fill(&http_auth);


#if LIBCURL_VERSION_NUM >= 0x071301
curl_easy_setopt(result, CURLOPT_USERNAME, http_auth.username); curl_easy_setopt(result, CURLOPT_USERNAME, http_auth.username);
curl_easy_setopt(result, CURLOPT_PASSWORD, http_auth.password); 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 */ /* *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) static void set_proxyauth_name_password(CURL *result)
{ {
#if LIBCURL_VERSION_NUM >= 0x071301
curl_easy_setopt(result, CURLOPT_PROXYUSERNAME, curl_easy_setopt(result, CURLOPT_PROXYUSERNAME,
proxy_auth.username); proxy_auth.username);
curl_easy_setopt(result, CURLOPT_PROXYPASSWORD, curl_easy_setopt(result, CURLOPT_PROXYPASSWORD,
proxy_auth.password); 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) 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")); var_override(&http_proxy_authmethod, getenv("GIT_HTTP_PROXY_AUTHMETHOD"));


#if LIBCURL_VERSION_NUM >= 0x070a07 /* CURLOPT_PROXYAUTH and CURLAUTH_ANY */
if (http_proxy_authmethod) { if (http_proxy_authmethod) {
int i; int i;
for (i = 0; i < ARRAY_SIZE(proxy_authmethods); i++) { for (i = 0; i < ARRAY_SIZE(proxy_authmethods); i++) {
@ -570,7 +484,6 @@ static void init_curl_proxy_auth(CURL *result)
} }
else else
curl_easy_setopt(result, CURLOPT_PROXYAUTH, CURLAUTH_ANY); curl_easy_setopt(result, CURLOPT_PROXYAUTH, CURLAUTH_ANY);
#endif
} }


static int has_cert_password(void) 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); 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) static int sockopt_callback(void *client, curl_socket_t fd, curlsocktype type)
{ {
int ka = 1; int ka = 1;
@ -630,12 +543,6 @@ static void set_curl_keepalive(CURL *c)
{ {
curl_easy_setopt(c, CURLOPT_SOCKOPTFUNCTION, sockopt_callback); curl_easy_setopt(c, CURLOPT_SOCKOPTFUNCTION, sockopt_callback);
} }

#else
static void set_curl_keepalive(CURL *c)
{
/* not supported on older curl versions */
}
#endif #endif


static void redact_sensitive_header(struct strbuf *header) 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); curl_easy_setopt(handle, CURLOPT_DEBUGDATA, NULL);
} }


#ifdef CURLPROTO_HTTP
static long get_curl_allowed_protocols(int from_user) static long get_curl_allowed_protocols(int from_user)
{ {
long allowed_protocols = 0; long allowed_protocols = 0;
@ -825,7 +731,6 @@ static long get_curl_allowed_protocols(int from_user)


return allowed_protocols; return allowed_protocols;
} }
#endif


#if LIBCURL_VERSION_NUM >=0x072f00 #if LIBCURL_VERSION_NUM >=0x072f00
static int get_curl_http_version_opt(const char *version_string, long *opt) static int get_curl_http_version_opt(const char *version_string, long *opt)
@ -879,12 +784,8 @@ static CURL *get_curl_handle(void)
} }
#endif #endif


#if LIBCURL_VERSION_NUM >= 0x070907
curl_easy_setopt(result, CURLOPT_NETRC, CURL_NETRC_OPTIONAL); curl_easy_setopt(result, CURLOPT_NETRC, CURL_NETRC_OPTIONAL);
#endif
#ifdef LIBCURL_CAN_HANDLE_AUTH_ANY
curl_easy_setopt(result, CURLOPT_HTTPAUTH, CURLAUTH_ANY); curl_easy_setopt(result, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
#endif


#ifdef CURLGSSAPI_DELEGATION_FLAG #ifdef CURLGSSAPI_DELEGATION_FLAG
if (curl_deleg) { if (curl_deleg) {
@ -940,14 +841,10 @@ static CURL *get_curl_handle(void)
curl_easy_setopt(result, CURLOPT_SSLCERT, ssl_cert); curl_easy_setopt(result, CURLOPT_SSLCERT, ssl_cert);
if (has_cert_password()) if (has_cert_password())
curl_easy_setopt(result, CURLOPT_KEYPASSWD, cert_auth.password); curl_easy_setopt(result, CURLOPT_KEYPASSWD, cert_auth.password);
#if LIBCURL_VERSION_NUM >= 0x070903
if (ssl_key != NULL) if (ssl_key != NULL)
curl_easy_setopt(result, CURLOPT_SSLKEY, ssl_key); curl_easy_setopt(result, CURLOPT_SSLKEY, ssl_key);
#endif
#if LIBCURL_VERSION_NUM >= 0x070908
if (ssl_capath != NULL) if (ssl_capath != NULL)
curl_easy_setopt(result, CURLOPT_CAPATH, ssl_capath); curl_easy_setopt(result, CURLOPT_CAPATH, ssl_capath);
#endif
#if LIBCURL_VERSION_NUM >= 0x072c00 #if LIBCURL_VERSION_NUM >= 0x072c00
if (ssl_pinnedkey != NULL) if (ssl_pinnedkey != NULL)
curl_easy_setopt(result, CURLOPT_PINNEDPUBLICKEY, ssl_pinnedkey); 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); curl_easy_setopt(result, CURLOPT_MAXREDIRS, 20);
#if LIBCURL_VERSION_NUM >= 0x071301
curl_easy_setopt(result, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL); 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, curl_easy_setopt(result, CURLOPT_REDIR_PROTOCOLS,
get_curl_allowed_protocols(0)); get_curl_allowed_protocols(0));
curl_easy_setopt(result, CURLOPT_PROTOCOLS, curl_easy_setopt(result, CURLOPT_PROTOCOLS,
get_curl_allowed_protocols(-1)); get_curl_allowed_protocols(-1));
#else
warning(_("Protocol restrictions not supported with cURL < 7.19.4"));
#endif
if (getenv("GIT_CURL_VERBOSE")) if (getenv("GIT_CURL_VERBOSE"))
http_trace_curl_no_data(); http_trace_curl_no_data();
setup_curl_trace(result); setup_curl_trace(result);
@ -1002,10 +891,8 @@ static CURL *get_curl_handle(void)
if (curl_ftp_no_epsv) if (curl_ftp_no_epsv)
curl_easy_setopt(result, CURLOPT_FTP_USE_EPSV, 0); curl_easy_setopt(result, CURLOPT_FTP_USE_EPSV, 0);


#ifdef CURLOPT_USE_SSL
if (curl_ssl_try) if (curl_ssl_try)
curl_easy_setopt(result, CURLOPT_USE_SSL, CURLUSESSL_TRY); curl_easy_setopt(result, CURLOPT_USE_SSL, CURLUSESSL_TRY);
#endif


/* /*
* CURL also examines these variables as a fallback; but we need to query * 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); die("Invalid proxy URL '%s'", curl_http_proxy);


curl_easy_setopt(result, CURLOPT_PROXY, proxy_auth.host); 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"));
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); curl_easy_setopt(result, CURLOPT_NOPROXY, curl_no_proxy);
#endif
} }
init_curl_proxy_auth(result); 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(), no_pragma_header = curl_slist_append(http_copy_default_headers(),
"Pragma:"); "Pragma:");


#ifdef USE_CURL_MULTI
{ {
char *http_max_requests = getenv("GIT_HTTP_MAX_REQUESTS"); char *http_max_requests = getenv("GIT_HTTP_MAX_REQUESTS");
if (http_max_requests != NULL) 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(); curlm = curl_multi_init();
if (!curlm) if (!curlm)
die("curl_multi_init failed"); die("curl_multi_init failed");
#endif


if (getenv("GIT_SSL_NO_VERIFY")) if (getenv("GIT_SSL_NO_VERIFY"))
curl_ssl_verify = 0; curl_ssl_verify = 0;


set_from_env(&ssl_cert, "GIT_SSL_CERT"); set_from_env(&ssl_cert, "GIT_SSL_CERT");
#if LIBCURL_VERSION_NUM >= 0x070903
set_from_env(&ssl_key, "GIT_SSL_KEY"); set_from_env(&ssl_key, "GIT_SSL_KEY");
#endif
#if LIBCURL_VERSION_NUM >= 0x070908
set_from_env(&ssl_capath, "GIT_SSL_CAPATH"); set_from_env(&ssl_capath, "GIT_SSL_CAPATH");
#endif
set_from_env(&ssl_cainfo, "GIT_SSL_CAINFO"); set_from_env(&ssl_cainfo, "GIT_SSL_CAINFO");


set_from_env(&user_agent, "GIT_HTTP_USER_AGENT"); 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_ssl_verify = 1;


curl_session_count = 0; curl_session_count = 0;
#ifdef USE_CURL_MULTI
if (max_requests < 1) if (max_requests < 1)
max_requests = DEFAULT_MAX_REQUESTS; max_requests = DEFAULT_MAX_REQUESTS;
#endif


set_from_env(&http_proxy_ssl_cert, "GIT_PROXY_SSL_CERT"); set_from_env(&http_proxy_ssl_cert, "GIT_PROXY_SSL_CERT");
set_from_env(&http_proxy_ssl_key, "GIT_PROXY_SSL_KEY"); 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; ssl_cert_password_required = 1;
} }


#ifndef NO_CURL_EASY_DUPHANDLE
curl_default = get_curl_handle(); curl_default = get_curl_handle();
#endif
} }


void http_cleanup(void) void http_cleanup(void)
@ -1244,13 +1119,9 @@ void http_cleanup(void)
} }
active_queue_head = NULL; active_queue_head = NULL;


#ifndef NO_CURL_EASY_DUPHANDLE
curl_easy_cleanup(curl_default); curl_easy_cleanup(curl_default);
#endif


#ifdef USE_CURL_MULTI
curl_multi_cleanup(curlm); curl_multi_cleanup(curlm);
#endif
curl_global_cleanup(); curl_global_cleanup();


string_list_clear(&extra_http_headers, 0); 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 *slot = active_queue_head;
struct active_request_slot *newslot; struct active_request_slot *newslot;


#ifdef USE_CURL_MULTI
int num_transfers; int num_transfers;


/* Wait for a slot to open up if the queue is full */ /* 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) if (num_transfers < active_requests)
process_curl_messages(); process_curl_messages();
} }
#endif


while (slot != NULL && slot->in_use) while (slot != NULL && slot->in_use)
slot = slot->next; slot = slot->next;
@ -1329,11 +1198,7 @@ struct active_request_slot *get_active_slot(void)
} }


if (slot->curl == NULL) { if (slot->curl == NULL) {
#ifdef NO_CURL_EASY_DUPHANDLE
slot->curl = get_curl_handle();
#else
slot->curl = curl_easy_duphandle(curl_default); slot->curl = curl_easy_duphandle(curl_default);
#endif
curl_session_count++; curl_session_count++;
} }


@ -1367,12 +1232,8 @@ struct active_request_slot *get_active_slot(void)
else else
curl_easy_setopt(slot->curl, CURLOPT_FOLLOWLOCATION, 0); curl_easy_setopt(slot->curl, CURLOPT_FOLLOWLOCATION, 0);


#if LIBCURL_VERSION_NUM >= 0x070a08
curl_easy_setopt(slot->curl, CURLOPT_IPRESOLVE, git_curl_ipresolve); 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); curl_easy_setopt(slot->curl, CURLOPT_HTTPAUTH, http_auth_methods);
#endif
if (http_auth.password || curl_empty_auth_enabled()) if (http_auth.password || curl_empty_auth_enabled())
init_curl_http_auth(slot->curl); 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) int start_active_slot(struct active_request_slot *slot)
{ {
#ifdef USE_CURL_MULTI
CURLMcode curlm_result = curl_multi_add_handle(curlm, slot->curl); CURLMcode curlm_result = curl_multi_add_handle(curlm, slot->curl);
int num_transfers; int num_transfers;


@ -1399,11 +1259,9 @@ int start_active_slot(struct active_request_slot *slot)
* something. * something.
*/ */
curl_multi_perform(curlm, &num_transfers); curl_multi_perform(curlm, &num_transfers);
#endif
return 1; return 1;
} }


#ifdef USE_CURL_MULTI
struct fill_chain { struct fill_chain {
void *data; void *data;
int (*fill)(void *); int (*fill)(void *);
@ -1462,11 +1320,9 @@ void step_active_slots(void)
fill_active_slots(); fill_active_slots();
} }
} }
#endif


void run_active_slot(struct active_request_slot *slot) void run_active_slot(struct active_request_slot *slot)
{ {
#ifdef USE_CURL_MULTI
fd_set readfds; fd_set readfds;
fd_set writefds; fd_set writefds;
fd_set excfds; fd_set excfds;
@ -1479,7 +1335,6 @@ void run_active_slot(struct active_request_slot *slot)
step_active_slots(); step_active_slots();


if (slot->in_use) { if (slot->in_use) {
#if LIBCURL_VERSION_NUM >= 0x070f04
long curl_timeout; long curl_timeout;
curl_multi_timeout(curlm, &curl_timeout); curl_multi_timeout(curlm, &curl_timeout);
if (curl_timeout == 0) { 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_sec = curl_timeout / 1000;
select_timeout.tv_usec = (curl_timeout % 1000) * 1000; select_timeout.tv_usec = (curl_timeout % 1000) * 1000;
} }
#else
select_timeout.tv_sec = 0;
select_timeout.tv_usec = 50000;
#endif


max_fd = -1; max_fd = -1;
FD_ZERO(&readfds); 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); 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) 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--; curl_session_count--;
} }
} }
#ifdef USE_CURL_MULTI
fill_active_slots(); fill_active_slots();
#endif
} }


void finish_all_active_slots(void) void finish_all_active_slots(void)
@ -1654,24 +1497,20 @@ static int handle_curl_result(struct slot_results *results)
credential_reject(&http_auth); credential_reject(&http_auth);
return HTTP_NOAUTH; return HTTP_NOAUTH;
} else { } else {
#ifdef LIBCURL_CAN_HANDLE_AUTH_ANY
http_auth_methods &= ~CURLAUTH_GSSNEGOTIATE; http_auth_methods &= ~CURLAUTH_GSSNEGOTIATE;
if (results->auth_avail) { if (results->auth_avail) {
http_auth_methods &= results->auth_avail; http_auth_methods &= results->auth_avail;
http_auth_methods_restricted = 1; http_auth_methods_restricted = 1;
} }
#endif
return HTTP_REAUTH; return HTTP_REAUTH;
} }
} else { } else {
if (results->http_connectcode == 407) if (results->http_connectcode == 407)
credential_reject(&proxy_auth); credential_reject(&proxy_auth);
#if LIBCURL_VERSION_NUM >= 0x070c00
if (!curl_errorstr[0]) if (!curl_errorstr[0])
strlcpy(curl_errorstr, strlcpy(curl_errorstr,
curl_easy_strerror(results->curl_result), curl_easy_strerror(results->curl_result),
sizeof(curl_errorstr)); sizeof(curl_errorstr));
#endif
return HTTP_ERROR; return HTTP_ERROR;
} }
} }
@ -1930,7 +1769,7 @@ static int http_request(const char *url,
curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 1); curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 1);
} else { } else {
curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 0); 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) { if (target == HTTP_REQUEST_FILE) {
off_t posn = ftello(result); off_t posn = ftello(result);
@ -2347,7 +2186,7 @@ struct http_pack_request *new_direct_http_pack_request(
} }


preq->slot = get_active_slot(); 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_WRITEFUNCTION, fwrite);
curl_easy_setopt(preq->slot->curl, CURLOPT_URL, preq->url); curl_easy_setopt(preq->slot->curl, CURLOPT_URL, preq->url);
curl_easy_setopt(preq->slot->curl, CURLOPT_HTTPHEADER, 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(); 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_FAILONERROR, 0);
curl_easy_setopt(freq->slot->curl, CURLOPT_WRITEFUNCTION, fwrite_sha1_file); curl_easy_setopt(freq->slot->curl, CURLOPT_WRITEFUNCTION, fwrite_sha1_file);
curl_easy_setopt(freq->slot->curl, CURLOPT_ERRORBUFFER, freq->errorstr); curl_easy_setopt(freq->slot->curl, CURLOPT_ERRORBUFFER, freq->errorstr);

46
http.h
View File

@ -10,49 +10,7 @@
#include "remote.h" #include "remote.h"
#include "url.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 #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 { struct slot_results {
CURLcode curl_result; 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 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_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); 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); curlioerr ioctl_buffer(CURL *handle, int cmd, void *clientp);
#endif


/* Slot lifecycle functions */ /* Slot lifecycle functions */
struct active_request_slot *get_active_slot(void); 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, int run_one_slot(struct active_request_slot *slot,
struct slot_results *results); struct slot_results *results);


#ifdef USE_CURL_MULTI
void fill_active_slots(void); void fill_active_slots(void);
void add_fill_function(void *data, int (*fill)(void *)); void add_fill_function(void *data, int (*fill)(void *));
void step_active_slots(void); void step_active_slots(void);
#endif


void http_init(struct remote *remote, const char *url, void http_init(struct remote *remote, const char *url,
int proactive_auth); int proactive_auth);

4
imap-send.c
View File

@ -1517,11 +1517,7 @@ static int curl_append_msgs_to_imap(struct imap_server_conf *server,
if (cred.username) { if (cred.username) {
if (res == CURLE_OK) if (res == CURLE_OK)
credential_approve(&cred); credential_approve(&cred);
#if LIBCURL_VERSION_NUM >= 0x070d01
else if (res == CURLE_LOGIN_DENIED) else if (res == CURLE_LOGIN_DENIED)
#else
else
#endif
credential_reject(&cred); credential_reject(&cred);
} }



11
remote-curl.c
View File

@ -185,8 +185,6 @@ static int set_option(const char *name, const char *value)
strbuf_detach(&unquoted, NULL)); strbuf_detach(&unquoted, NULL));
} }
return 0; return 0;

#if LIBCURL_VERSION_NUM >= 0x070a08
} else if (!strcmp(name, "family")) { } else if (!strcmp(name, "family")) {
if (!strcmp(value, "ipv4")) if (!strcmp(value, "ipv4"))
git_curl_ipresolve = CURL_IPRESOLVE_V4; git_curl_ipresolve = CURL_IPRESOLVE_V4;
@ -197,7 +195,6 @@ static int set_option(const char *name, const char *value)
else else
return -1; return -1;
return 0; return 0;
#endif /* LIBCURL_VERSION_NUM >= 0x070a08 */
} else if (!strcmp(name, "from-promisor")) { } else if (!strcmp(name, "from-promisor")) {
options.from_promisor = 1; options.from_promisor = 1;
return 0; return 0;
@ -709,7 +706,6 @@ static size_t rpc_out(void *ptr, size_t eltsize,
return avail; return avail;
} }


#ifndef NO_CURL_IOCTL
static curlioerr rpc_ioctl(CURL *handle, int cmd, void *clientp) static curlioerr rpc_ioctl(CURL *handle, int cmd, void *clientp)
{ {
struct rpc_state *rpc = clientp; struct rpc_state *rpc = clientp;
@ -730,7 +726,6 @@ static curlioerr rpc_ioctl(CURL *handle, int cmd, void *clientp)
return CURLIOE_UNKNOWNCMD; return CURLIOE_UNKNOWNCMD;
} }
} }
#endif


struct check_pktline_state { struct check_pktline_state {
char len_buf[4]; 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_POSTFIELDSIZE, 4);
curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, headers); curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer); 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); err = run_slot(slot, results);


@ -949,10 +944,8 @@ retry:
rpc->initial_buffer = 1; rpc->initial_buffer = 1;
curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, rpc_out); curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, rpc_out);
curl_easy_setopt(slot->curl, CURLOPT_INFILE, rpc); 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_IOCTLFUNCTION, rpc_ioctl);
curl_easy_setopt(slot->curl, CURLOPT_IOCTLDATA, rpc); curl_easy_setopt(slot->curl, CURLOPT_IOCTLDATA, rpc);
#endif
if (options.verbosity > 1) { if (options.verbosity > 1) {
fprintf(stderr, "POST %s (chunked)\n", rpc->service_name); fprintf(stderr, "POST %s (chunked)\n", rpc->service_name);
fflush(stderr); fflush(stderr);
@ -1023,7 +1016,7 @@ retry:
rpc_in_data.slot = slot; rpc_in_data.slot = slot;
rpc_in_data.check_pktline = stateless_connect; rpc_in_data.check_pktline = stateless_connect;
memset(&rpc_in_data.pktline_state, 0, sizeof(rpc_in_data.pktline_state)); 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); curl_easy_setopt(slot->curl, CURLOPT_FAILONERROR, 0);