mirror of
https://github.com/git/git
synced 2024-08-27 19:49:21 +00:00
![Shawn O. Pearce](/assets/img/avatar_default.png)
The git-remote-curl backend detects if the remote server supports the git-receive-pack service, and if so, runs git-send-pack in a pipe to dump the command and pack data as a single POST request. The advertisements from the server that were obtained during the discovery are passed into git-send-pack before the POST request starts. This permits git-send-pack to operate largely unmodified. For smaller packs (those under 1 MiB) a HTTP/1.0 POST with a Content-Length is used, permitting interaction with any server. The 1 MiB limit is arbitrary, but is sufficent to fit most deltas created by human authors against text sources with the occasional small binary file (e.g. few KiB icon image). The configuration option http.postBuffer can be used to increase (or shink) this buffer if the default is not sufficient. For larger packs which cannot be spooled entirely into the helper's memory space (due to http.postBuffer being too small), the POST request requires HTTP/1.1 and sets "Transfer-Encoding: chunked". This permits the client to upload an unknown amount of data in one HTTP transaction without needing to pregenerate the entire pack file locally. Signed-off-by: Shawn O. Pearce <spearce@spearce.org> CC: Daniel Barkalow <barkalow@iabervon.org> Signed-off-by: Junio C Hamano <gitster@pobox.com>
1295 lines
30 KiB
C
1295 lines
30 KiB
C
#include "http.h"
|
|
#include "pack.h"
|
|
#include "sideband.h"
|
|
|
|
int data_received;
|
|
int active_requests;
|
|
int http_is_verbose;
|
|
size_t http_post_buffer = 16 * LARGE_PACKET_MAX;
|
|
|
|
#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
|
|
#define RANGE_HEADER_SIZE 30
|
|
|
|
char curl_errorstr[CURL_ERROR_SIZE];
|
|
|
|
static int curl_ssl_verify = -1;
|
|
static const char *ssl_cert;
|
|
#if LIBCURL_VERSION_NUM >= 0x070903
|
|
static const char *ssl_key;
|
|
#endif
|
|
#if LIBCURL_VERSION_NUM >= 0x070908
|
|
static const char *ssl_capath;
|
|
#endif
|
|
static const char *ssl_cainfo;
|
|
static long curl_low_speed_limit = -1;
|
|
static long curl_low_speed_time = -1;
|
|
static int curl_ftp_no_epsv;
|
|
static const char *curl_http_proxy;
|
|
static char *user_name, *user_pass;
|
|
|
|
#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 char *ssl_cert_password;
|
|
static int ssl_cert_password_required;
|
|
|
|
static struct curl_slist *pragma_header;
|
|
static struct curl_slist *no_pragma_header;
|
|
|
|
static struct active_request_slot *active_queue_head;
|
|
|
|
size_t fread_buffer(void *ptr, size_t eltsize, size_t nmemb, void *buffer_)
|
|
{
|
|
size_t size = eltsize * nmemb;
|
|
struct buffer *buffer = buffer_;
|
|
|
|
if (size > buffer->buf.len - buffer->posn)
|
|
size = buffer->buf.len - buffer->posn;
|
|
memcpy(ptr, buffer->buf.buf + buffer->posn, size);
|
|
buffer->posn += size;
|
|
|
|
return size;
|
|
}
|
|
|
|
#ifndef NO_CURL_IOCTL
|
|
curlioerr ioctl_buffer(CURL *handle, int cmd, void *clientp)
|
|
{
|
|
struct buffer *buffer = clientp;
|
|
|
|
switch (cmd) {
|
|
case CURLIOCMD_NOP:
|
|
return CURLIOE_OK;
|
|
|
|
case CURLIOCMD_RESTARTREAD:
|
|
buffer->posn = 0;
|
|
return CURLIOE_OK;
|
|
|
|
default:
|
|
return CURLIOE_UNKNOWNCMD;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
size_t fwrite_buffer(const void *ptr, size_t eltsize, size_t nmemb, void *buffer_)
|
|
{
|
|
size_t size = eltsize * nmemb;
|
|
struct strbuf *buffer = buffer_;
|
|
|
|
strbuf_add(buffer, ptr, size);
|
|
data_received++;
|
|
return size;
|
|
}
|
|
|
|
size_t fwrite_null(const void *ptr, size_t eltsize, size_t nmemb, void *strbuf)
|
|
{
|
|
data_received++;
|
|
return eltsize * nmemb;
|
|
}
|
|
|
|
#ifdef USE_CURL_MULTI
|
|
static void process_curl_messages(void)
|
|
{
|
|
int num_messages;
|
|
struct active_request_slot *slot;
|
|
CURLMsg *curl_message = curl_multi_info_read(curlm, &num_messages);
|
|
|
|
while (curl_message != NULL) {
|
|
if (curl_message->msg == CURLMSG_DONE) {
|
|
int curl_result = curl_message->data.result;
|
|
slot = active_queue_head;
|
|
while (slot != NULL &&
|
|
slot->curl != curl_message->easy_handle)
|
|
slot = slot->next;
|
|
if (slot != NULL) {
|
|
curl_multi_remove_handle(curlm, slot->curl);
|
|
slot->curl_result = curl_result;
|
|
finish_active_slot(slot);
|
|
} else {
|
|
fprintf(stderr, "Received DONE message for unknown request!\n");
|
|
}
|
|
} else {
|
|
fprintf(stderr, "Unknown CURL message received: %d\n",
|
|
(int)curl_message->msg);
|
|
}
|
|
curl_message = curl_multi_info_read(curlm, &num_messages);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static int http_options(const char *var, const char *value, void *cb)
|
|
{
|
|
if (!strcmp("http.sslverify", var)) {
|
|
curl_ssl_verify = git_config_bool(var, value);
|
|
return 0;
|
|
}
|
|
if (!strcmp("http.sslcert", var))
|
|
return git_config_string(&ssl_cert, var, value);
|
|
#if LIBCURL_VERSION_NUM >= 0x070903
|
|
if (!strcmp("http.sslkey", var))
|
|
return git_config_string(&ssl_key, var, value);
|
|
#endif
|
|
#if LIBCURL_VERSION_NUM >= 0x070908
|
|
if (!strcmp("http.sslcapath", var))
|
|
return git_config_string(&ssl_capath, var, value);
|
|
#endif
|
|
if (!strcmp("http.sslcainfo", var))
|
|
return git_config_string(&ssl_cainfo, var, value);
|
|
if (!strcmp("http.sslcertpasswordprotected", var)) {
|
|
if (git_config_bool(var, value))
|
|
ssl_cert_password_required = 1;
|
|
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;
|
|
}
|
|
if (!strcmp("http.lowspeedtime", var)) {
|
|
curl_low_speed_time = (long)git_config_int(var, value);
|
|
return 0;
|
|
}
|
|
|
|
if (!strcmp("http.noepsv", var)) {
|
|
curl_ftp_no_epsv = git_config_bool(var, value);
|
|
return 0;
|
|
}
|
|
if (!strcmp("http.proxy", var))
|
|
return git_config_string(&curl_http_proxy, var, value);
|
|
|
|
if (!strcmp("http.postbuffer", var)) {
|
|
http_post_buffer = git_config_int(var, value);
|
|
if (http_post_buffer < LARGE_PACKET_MAX)
|
|
http_post_buffer = LARGE_PACKET_MAX;
|
|
return 0;
|
|
}
|
|
|
|
/* Fall back on the default ones */
|
|
return git_default_config(var, value, cb);
|
|
}
|
|
|
|
static void init_curl_http_auth(CURL *result)
|
|
{
|
|
if (user_name) {
|
|
struct strbuf up = STRBUF_INIT;
|
|
if (!user_pass)
|
|
user_pass = xstrdup(getpass("Password: "));
|
|
strbuf_addf(&up, "%s:%s", user_name, user_pass);
|
|
curl_easy_setopt(result, CURLOPT_USERPWD,
|
|
strbuf_detach(&up, NULL));
|
|
}
|
|
}
|
|
|
|
static int has_cert_password(void)
|
|
{
|
|
if (ssl_cert_password != NULL)
|
|
return 1;
|
|
if (ssl_cert == NULL || ssl_cert_password_required != 1)
|
|
return 0;
|
|
/* Only prompt the user once. */
|
|
ssl_cert_password_required = -1;
|
|
ssl_cert_password = getpass("Certificate Password: ");
|
|
if (ssl_cert_password != NULL) {
|
|
ssl_cert_password = xstrdup(ssl_cert_password);
|
|
return 1;
|
|
} else
|
|
return 0;
|
|
}
|
|
|
|
static CURL *get_curl_handle(void)
|
|
{
|
|
CURL *result = curl_easy_init();
|
|
|
|
if (!curl_ssl_verify) {
|
|
curl_easy_setopt(result, CURLOPT_SSL_VERIFYPEER, 0);
|
|
curl_easy_setopt(result, CURLOPT_SSL_VERIFYHOST, 0);
|
|
} else {
|
|
/* Verify authenticity of the peer's certificate */
|
|
curl_easy_setopt(result, CURLOPT_SSL_VERIFYPEER, 1);
|
|
/* The name in the cert must match whom we tried to connect */
|
|
curl_easy_setopt(result, CURLOPT_SSL_VERIFYHOST, 2);
|
|
}
|
|
|
|
#if LIBCURL_VERSION_NUM >= 0x070907
|
|
curl_easy_setopt(result, CURLOPT_NETRC, CURL_NETRC_OPTIONAL);
|
|
#endif
|
|
|
|
init_curl_http_auth(result);
|
|
|
|
if (ssl_cert != NULL)
|
|
curl_easy_setopt(result, CURLOPT_SSLCERT, ssl_cert);
|
|
if (has_cert_password())
|
|
curl_easy_setopt(result, CURLOPT_KEYPASSWD, ssl_cert_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 (ssl_cainfo != NULL)
|
|
curl_easy_setopt(result, CURLOPT_CAINFO, ssl_cainfo);
|
|
curl_easy_setopt(result, CURLOPT_FAILONERROR, 1);
|
|
|
|
if (curl_low_speed_limit > 0 && curl_low_speed_time > 0) {
|
|
curl_easy_setopt(result, CURLOPT_LOW_SPEED_LIMIT,
|
|
curl_low_speed_limit);
|
|
curl_easy_setopt(result, CURLOPT_LOW_SPEED_TIME,
|
|
curl_low_speed_time);
|
|
}
|
|
|
|
curl_easy_setopt(result, CURLOPT_FOLLOWLOCATION, 1);
|
|
|
|
if (getenv("GIT_CURL_VERBOSE"))
|
|
curl_easy_setopt(result, CURLOPT_VERBOSE, 1);
|
|
|
|
curl_easy_setopt(result, CURLOPT_USERAGENT, GIT_USER_AGENT);
|
|
|
|
if (curl_ftp_no_epsv)
|
|
curl_easy_setopt(result, CURLOPT_FTP_USE_EPSV, 0);
|
|
|
|
if (curl_http_proxy)
|
|
curl_easy_setopt(result, CURLOPT_PROXY, curl_http_proxy);
|
|
|
|
return result;
|
|
}
|
|
|
|
static void http_auth_init(const char *url)
|
|
{
|
|
char *at, *colon, *cp, *slash;
|
|
int len;
|
|
|
|
cp = strstr(url, "://");
|
|
if (!cp)
|
|
return;
|
|
|
|
/*
|
|
* Ok, the URL looks like "proto://something". Which one?
|
|
* "proto://<user>:<pass>@<host>/...",
|
|
* "proto://<user>@<host>/...", or just
|
|
* "proto://<host>/..."?
|
|
*/
|
|
cp += 3;
|
|
at = strchr(cp, '@');
|
|
colon = strchr(cp, ':');
|
|
slash = strchrnul(cp, '/');
|
|
if (!at || slash <= at)
|
|
return; /* No credentials */
|
|
if (!colon || at <= colon) {
|
|
/* Only username */
|
|
len = at - cp;
|
|
user_name = xmalloc(len + 1);
|
|
memcpy(user_name, cp, len);
|
|
user_name[len] = '\0';
|
|
user_pass = NULL;
|
|
} else {
|
|
len = colon - cp;
|
|
user_name = xmalloc(len + 1);
|
|
memcpy(user_name, cp, len);
|
|
user_name[len] = '\0';
|
|
len = at - (colon + 1);
|
|
user_pass = xmalloc(len + 1);
|
|
memcpy(user_pass, colon + 1, len);
|
|
user_pass[len] = '\0';
|
|
}
|
|
}
|
|
|
|
static void set_from_env(const char **var, const char *envname)
|
|
{
|
|
const char *val = getenv(envname);
|
|
if (val)
|
|
*var = val;
|
|
}
|
|
|
|
void http_init(struct remote *remote)
|
|
{
|
|
char *low_speed_limit;
|
|
char *low_speed_time;
|
|
|
|
http_is_verbose = 0;
|
|
|
|
git_config(http_options, NULL);
|
|
|
|
curl_global_init(CURL_GLOBAL_ALL);
|
|
|
|
if (remote && remote->http_proxy)
|
|
curl_http_proxy = xstrdup(remote->http_proxy);
|
|
|
|
pragma_header = curl_slist_append(pragma_header, "Pragma: no-cache");
|
|
no_pragma_header = curl_slist_append(no_pragma_header, "Pragma:");
|
|
|
|
#ifdef USE_CURL_MULTI
|
|
{
|
|
char *http_max_requests = getenv("GIT_HTTP_MAX_REQUESTS");
|
|
if (http_max_requests != NULL)
|
|
max_requests = atoi(http_max_requests);
|
|
}
|
|
|
|
curlm = curl_multi_init();
|
|
if (curlm == NULL) {
|
|
fprintf(stderr, "Error creating curl multi handle.\n");
|
|
exit(1);
|
|
}
|
|
#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");
|
|
|
|
low_speed_limit = getenv("GIT_HTTP_LOW_SPEED_LIMIT");
|
|
if (low_speed_limit != NULL)
|
|
curl_low_speed_limit = strtol(low_speed_limit, NULL, 10);
|
|
low_speed_time = getenv("GIT_HTTP_LOW_SPEED_TIME");
|
|
if (low_speed_time != NULL)
|
|
curl_low_speed_time = strtol(low_speed_time, NULL, 10);
|
|
|
|
if (curl_ssl_verify == -1)
|
|
curl_ssl_verify = 1;
|
|
|
|
#ifdef USE_CURL_MULTI
|
|
if (max_requests < 1)
|
|
max_requests = DEFAULT_MAX_REQUESTS;
|
|
#endif
|
|
|
|
if (getenv("GIT_CURL_FTP_NO_EPSV"))
|
|
curl_ftp_no_epsv = 1;
|
|
|
|
if (remote && remote->url && remote->url[0]) {
|
|
http_auth_init(remote->url[0]);
|
|
if (!ssl_cert_password_required &&
|
|
getenv("GIT_SSL_CERT_PASSWORD_PROTECTED") &&
|
|
!prefixcmp(remote->url[0], "https://"))
|
|
ssl_cert_password_required = 1;
|
|
}
|
|
|
|
#ifndef NO_CURL_EASY_DUPHANDLE
|
|
curl_default = get_curl_handle();
|
|
#endif
|
|
}
|
|
|
|
void http_cleanup(void)
|
|
{
|
|
struct active_request_slot *slot = active_queue_head;
|
|
|
|
while (slot != NULL) {
|
|
struct active_request_slot *next = slot->next;
|
|
if (slot->curl != NULL) {
|
|
#ifdef USE_CURL_MULTI
|
|
curl_multi_remove_handle(curlm, slot->curl);
|
|
#endif
|
|
curl_easy_cleanup(slot->curl);
|
|
}
|
|
free(slot);
|
|
slot = next;
|
|
}
|
|
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();
|
|
|
|
curl_slist_free_all(pragma_header);
|
|
pragma_header = NULL;
|
|
|
|
curl_slist_free_all(no_pragma_header);
|
|
no_pragma_header = NULL;
|
|
|
|
if (curl_http_proxy) {
|
|
free((void *)curl_http_proxy);
|
|
curl_http_proxy = NULL;
|
|
}
|
|
|
|
if (ssl_cert_password != NULL) {
|
|
memset(ssl_cert_password, 0, strlen(ssl_cert_password));
|
|
free(ssl_cert_password);
|
|
ssl_cert_password = NULL;
|
|
}
|
|
ssl_cert_password_required = 0;
|
|
}
|
|
|
|
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 */
|
|
while (active_requests >= max_requests) {
|
|
curl_multi_perform(curlm, &num_transfers);
|
|
if (num_transfers < active_requests)
|
|
process_curl_messages();
|
|
}
|
|
#endif
|
|
|
|
while (slot != NULL && slot->in_use)
|
|
slot = slot->next;
|
|
|
|
if (slot == NULL) {
|
|
newslot = xmalloc(sizeof(*newslot));
|
|
newslot->curl = NULL;
|
|
newslot->in_use = 0;
|
|
newslot->next = NULL;
|
|
|
|
slot = active_queue_head;
|
|
if (slot == NULL) {
|
|
active_queue_head = newslot;
|
|
} else {
|
|
while (slot->next != NULL)
|
|
slot = slot->next;
|
|
slot->next = newslot;
|
|
}
|
|
slot = newslot;
|
|
}
|
|
|
|
if (slot->curl == NULL) {
|
|
#ifdef NO_CURL_EASY_DUPHANDLE
|
|
slot->curl = get_curl_handle();
|
|
#else
|
|
slot->curl = curl_easy_duphandle(curl_default);
|
|
#endif
|
|
}
|
|
|
|
active_requests++;
|
|
slot->in_use = 1;
|
|
slot->local = NULL;
|
|
slot->results = NULL;
|
|
slot->finished = NULL;
|
|
slot->callback_data = NULL;
|
|
slot->callback_func = NULL;
|
|
curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, pragma_header);
|
|
curl_easy_setopt(slot->curl, CURLOPT_ERRORBUFFER, curl_errorstr);
|
|
curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, NULL);
|
|
curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, NULL);
|
|
curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, NULL);
|
|
curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 0);
|
|
curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1);
|
|
|
|
return slot;
|
|
}
|
|
|
|
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;
|
|
|
|
if (curlm_result != CURLM_OK &&
|
|
curlm_result != CURLM_CALL_MULTI_PERFORM) {
|
|
active_requests--;
|
|
slot->in_use = 0;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* We know there must be something to do, since we just added
|
|
* something.
|
|
*/
|
|
curl_multi_perform(curlm, &num_transfers);
|
|
#endif
|
|
return 1;
|
|
}
|
|
|
|
#ifdef USE_CURL_MULTI
|
|
struct fill_chain {
|
|
void *data;
|
|
int (*fill)(void *);
|
|
struct fill_chain *next;
|
|
};
|
|
|
|
static struct fill_chain *fill_cfg;
|
|
|
|
void add_fill_function(void *data, int (*fill)(void *))
|
|
{
|
|
struct fill_chain *new = xmalloc(sizeof(*new));
|
|
struct fill_chain **linkp = &fill_cfg;
|
|
new->data = data;
|
|
new->fill = fill;
|
|
new->next = NULL;
|
|
while (*linkp)
|
|
linkp = &(*linkp)->next;
|
|
*linkp = new;
|
|
}
|
|
|
|
void fill_active_slots(void)
|
|
{
|
|
struct active_request_slot *slot = active_queue_head;
|
|
|
|
while (active_requests < max_requests) {
|
|
struct fill_chain *fill;
|
|
for (fill = fill_cfg; fill; fill = fill->next)
|
|
if (fill->fill(fill->data))
|
|
break;
|
|
|
|
if (!fill)
|
|
break;
|
|
}
|
|
|
|
while (slot != NULL) {
|
|
if (!slot->in_use && slot->curl != NULL) {
|
|
curl_easy_cleanup(slot->curl);
|
|
slot->curl = NULL;
|
|
}
|
|
slot = slot->next;
|
|
}
|
|
}
|
|
|
|
void step_active_slots(void)
|
|
{
|
|
int num_transfers;
|
|
CURLMcode curlm_result;
|
|
|
|
do {
|
|
curlm_result = curl_multi_perform(curlm, &num_transfers);
|
|
} while (curlm_result == CURLM_CALL_MULTI_PERFORM);
|
|
if (num_transfers < active_requests) {
|
|
process_curl_messages();
|
|
fill_active_slots();
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void run_active_slot(struct active_request_slot *slot)
|
|
{
|
|
#ifdef USE_CURL_MULTI
|
|
long last_pos = 0;
|
|
long current_pos;
|
|
fd_set readfds;
|
|
fd_set writefds;
|
|
fd_set excfds;
|
|
int max_fd;
|
|
struct timeval select_timeout;
|
|
int finished = 0;
|
|
|
|
slot->finished = &finished;
|
|
while (!finished) {
|
|
data_received = 0;
|
|
step_active_slots();
|
|
|
|
if (!data_received && slot->local != NULL) {
|
|
current_pos = ftell(slot->local);
|
|
if (current_pos > last_pos)
|
|
data_received++;
|
|
last_pos = current_pos;
|
|
}
|
|
|
|
if (slot->in_use && !data_received) {
|
|
max_fd = 0;
|
|
FD_ZERO(&readfds);
|
|
FD_ZERO(&writefds);
|
|
FD_ZERO(&excfds);
|
|
select_timeout.tv_sec = 0;
|
|
select_timeout.tv_usec = 50000;
|
|
select(max_fd, &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 closedown_active_slot(struct active_request_slot *slot)
|
|
{
|
|
active_requests--;
|
|
slot->in_use = 0;
|
|
}
|
|
|
|
void release_active_slot(struct active_request_slot *slot)
|
|
{
|
|
closedown_active_slot(slot);
|
|
if (slot->curl) {
|
|
#ifdef USE_CURL_MULTI
|
|
curl_multi_remove_handle(curlm, slot->curl);
|
|
#endif
|
|
curl_easy_cleanup(slot->curl);
|
|
slot->curl = NULL;
|
|
}
|
|
#ifdef USE_CURL_MULTI
|
|
fill_active_slots();
|
|
#endif
|
|
}
|
|
|
|
void finish_active_slot(struct active_request_slot *slot)
|
|
{
|
|
closedown_active_slot(slot);
|
|
curl_easy_getinfo(slot->curl, CURLINFO_HTTP_CODE, &slot->http_code);
|
|
|
|
if (slot->finished != NULL)
|
|
(*slot->finished) = 1;
|
|
|
|
/* Store slot results so they can be read after the slot is reused */
|
|
if (slot->results != NULL) {
|
|
slot->results->curl_result = slot->curl_result;
|
|
slot->results->http_code = slot->http_code;
|
|
}
|
|
|
|
/* Run callback if appropriate */
|
|
if (slot->callback_func != NULL)
|
|
slot->callback_func(slot->callback_data);
|
|
}
|
|
|
|
void finish_all_active_slots(void)
|
|
{
|
|
struct active_request_slot *slot = active_queue_head;
|
|
|
|
while (slot != NULL)
|
|
if (slot->in_use) {
|
|
run_active_slot(slot);
|
|
slot = active_queue_head;
|
|
} else {
|
|
slot = slot->next;
|
|
}
|
|
}
|
|
|
|
/* Helpers for modifying and creating URLs */
|
|
static inline int needs_quote(int ch)
|
|
{
|
|
if (((ch >= 'A') && (ch <= 'Z'))
|
|
|| ((ch >= 'a') && (ch <= 'z'))
|
|
|| ((ch >= '0') && (ch <= '9'))
|
|
|| (ch == '/')
|
|
|| (ch == '-')
|
|
|| (ch == '.'))
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
static inline int hex(int v)
|
|
{
|
|
if (v < 10)
|
|
return '0' + v;
|
|
else
|
|
return 'A' + v - 10;
|
|
}
|
|
|
|
static void end_url_with_slash(struct strbuf *buf, const char *url)
|
|
{
|
|
strbuf_addstr(buf, url);
|
|
if (buf->len && buf->buf[buf->len - 1] != '/')
|
|
strbuf_addstr(buf, "/");
|
|
}
|
|
|
|
static char *quote_ref_url(const char *base, const char *ref)
|
|
{
|
|
struct strbuf buf = STRBUF_INIT;
|
|
const char *cp;
|
|
int ch;
|
|
|
|
end_url_with_slash(&buf, base);
|
|
|
|
for (cp = ref; (ch = *cp) != 0; cp++)
|
|
if (needs_quote(ch))
|
|
strbuf_addf(&buf, "%%%02x", ch);
|
|
else
|
|
strbuf_addch(&buf, *cp);
|
|
|
|
return strbuf_detach(&buf, NULL);
|
|
}
|
|
|
|
void append_remote_object_url(struct strbuf *buf, const char *url,
|
|
const char *hex,
|
|
int only_two_digit_prefix)
|
|
{
|
|
end_url_with_slash(buf, url);
|
|
|
|
strbuf_addf(buf, "objects/%.*s/", 2, hex);
|
|
if (!only_two_digit_prefix)
|
|
strbuf_addf(buf, "%s", hex+2);
|
|
}
|
|
|
|
char *get_remote_object_url(const char *url, const char *hex,
|
|
int only_two_digit_prefix)
|
|
{
|
|
struct strbuf buf = STRBUF_INIT;
|
|
append_remote_object_url(&buf, url, hex, only_two_digit_prefix);
|
|
return strbuf_detach(&buf, NULL);
|
|
}
|
|
|
|
/* http_request() targets */
|
|
#define HTTP_REQUEST_STRBUF 0
|
|
#define HTTP_REQUEST_FILE 1
|
|
|
|
static int http_request(const char *url, void *result, int target, int options)
|
|
{
|
|
struct active_request_slot *slot;
|
|
struct slot_results results;
|
|
struct curl_slist *headers = NULL;
|
|
struct strbuf buf = STRBUF_INIT;
|
|
int ret;
|
|
|
|
slot = get_active_slot();
|
|
slot->results = &results;
|
|
curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1);
|
|
|
|
if (result == NULL) {
|
|
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);
|
|
|
|
if (target == HTTP_REQUEST_FILE) {
|
|
long posn = ftell(result);
|
|
curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION,
|
|
fwrite);
|
|
if (posn > 0) {
|
|
strbuf_addf(&buf, "Range: bytes=%ld-", posn);
|
|
headers = curl_slist_append(headers, buf.buf);
|
|
strbuf_reset(&buf);
|
|
}
|
|
slot->local = result;
|
|
} else
|
|
curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION,
|
|
fwrite_buffer);
|
|
}
|
|
|
|
strbuf_addstr(&buf, "Pragma:");
|
|
if (options & HTTP_NO_CACHE)
|
|
strbuf_addstr(&buf, " no-cache");
|
|
|
|
headers = curl_slist_append(headers, buf.buf);
|
|
|
|
curl_easy_setopt(slot->curl, CURLOPT_URL, url);
|
|
curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, headers);
|
|
|
|
if (start_active_slot(slot)) {
|
|
run_active_slot(slot);
|
|
if (results.curl_result == CURLE_OK)
|
|
ret = HTTP_OK;
|
|
else if (missing_target(&results))
|
|
ret = HTTP_MISSING_TARGET;
|
|
else
|
|
ret = HTTP_ERROR;
|
|
} else {
|
|
error("Unable to start HTTP request for %s", url);
|
|
ret = HTTP_START_FAILED;
|
|
}
|
|
|
|
slot->local = NULL;
|
|
curl_slist_free_all(headers);
|
|
strbuf_release(&buf);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int http_get_strbuf(const char *url, struct strbuf *result, int options)
|
|
{
|
|
return http_request(url, result, HTTP_REQUEST_STRBUF, options);
|
|
}
|
|
|
|
int http_get_file(const char *url, const char *filename, int options)
|
|
{
|
|
int ret;
|
|
struct strbuf tmpfile = STRBUF_INIT;
|
|
FILE *result;
|
|
|
|
strbuf_addf(&tmpfile, "%s.temp", filename);
|
|
result = fopen(tmpfile.buf, "a");
|
|
if (! result) {
|
|
error("Unable to open local file %s", tmpfile.buf);
|
|
ret = HTTP_ERROR;
|
|
goto cleanup;
|
|
}
|
|
|
|
ret = http_request(url, result, HTTP_REQUEST_FILE, options);
|
|
fclose(result);
|
|
|
|
if ((ret == HTTP_OK) && move_temp_to_file(tmpfile.buf, filename))
|
|
ret = HTTP_ERROR;
|
|
cleanup:
|
|
strbuf_release(&tmpfile);
|
|
return ret;
|
|
}
|
|
|
|
int http_error(const char *url, int ret)
|
|
{
|
|
/* http_request has already handled HTTP_START_FAILED. */
|
|
if (ret != HTTP_START_FAILED)
|
|
error("%s while accessing %s\n", curl_errorstr, url);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int http_fetch_ref(const char *base, struct ref *ref)
|
|
{
|
|
char *url;
|
|
struct strbuf buffer = STRBUF_INIT;
|
|
int ret = -1;
|
|
|
|
url = quote_ref_url(base, ref->name);
|
|
if (http_get_strbuf(url, &buffer, HTTP_NO_CACHE) == HTTP_OK) {
|
|
strbuf_rtrim(&buffer);
|
|
if (buffer.len == 40)
|
|
ret = get_sha1_hex(buffer.buf, ref->old_sha1);
|
|
else if (!prefixcmp(buffer.buf, "ref: ")) {
|
|
ref->symref = xstrdup(buffer.buf + 5);
|
|
ret = 0;
|
|
}
|
|
}
|
|
|
|
strbuf_release(&buffer);
|
|
free(url);
|
|
return ret;
|
|
}
|
|
|
|
/* Helpers for fetching packs */
|
|
static int fetch_pack_index(unsigned char *sha1, const char *base_url)
|
|
{
|
|
int ret = 0;
|
|
char *hex = xstrdup(sha1_to_hex(sha1));
|
|
char *filename;
|
|
char *url = NULL;
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
if (has_pack_index(sha1)) {
|
|
ret = 0;
|
|
goto cleanup;
|
|
}
|
|
|
|
if (http_is_verbose)
|
|
fprintf(stderr, "Getting index for pack %s\n", hex);
|
|
|
|
end_url_with_slash(&buf, base_url);
|
|
strbuf_addf(&buf, "objects/pack/pack-%s.idx", hex);
|
|
url = strbuf_detach(&buf, NULL);
|
|
|
|
filename = sha1_pack_index_name(sha1);
|
|
if (http_get_file(url, filename, 0) != HTTP_OK)
|
|
ret = error("Unable to get pack index %s\n", url);
|
|
|
|
cleanup:
|
|
free(hex);
|
|
free(url);
|
|
return ret;
|
|
}
|
|
|
|
static int fetch_and_setup_pack_index(struct packed_git **packs_head,
|
|
unsigned char *sha1, const char *base_url)
|
|
{
|
|
struct packed_git *new_pack;
|
|
|
|
if (fetch_pack_index(sha1, base_url))
|
|
return -1;
|
|
|
|
new_pack = parse_pack_index(sha1);
|
|
if (!new_pack)
|
|
return -1; /* parse_pack_index() already issued error message */
|
|
new_pack->next = *packs_head;
|
|
*packs_head = new_pack;
|
|
return 0;
|
|
}
|
|
|
|
int http_get_info_packs(const char *base_url, struct packed_git **packs_head)
|
|
{
|
|
int ret = 0, i = 0;
|
|
char *url, *data;
|
|
struct strbuf buf = STRBUF_INIT;
|
|
unsigned char sha1[20];
|
|
|
|
end_url_with_slash(&buf, base_url);
|
|
strbuf_addstr(&buf, "objects/info/packs");
|
|
url = strbuf_detach(&buf, NULL);
|
|
|
|
ret = http_get_strbuf(url, &buf, HTTP_NO_CACHE);
|
|
if (ret != HTTP_OK)
|
|
goto cleanup;
|
|
|
|
data = buf.buf;
|
|
while (i < buf.len) {
|
|
switch (data[i]) {
|
|
case 'P':
|
|
i++;
|
|
if (i + 52 <= buf.len &&
|
|
!prefixcmp(data + i, " pack-") &&
|
|
!prefixcmp(data + i + 46, ".pack\n")) {
|
|
get_sha1_hex(data + i + 6, sha1);
|
|
fetch_and_setup_pack_index(packs_head, sha1,
|
|
base_url);
|
|
i += 51;
|
|
break;
|
|
}
|
|
default:
|
|
while (i < buf.len && data[i] != '\n')
|
|
i++;
|
|
}
|
|
i++;
|
|
}
|
|
|
|
cleanup:
|
|
free(url);
|
|
return ret;
|
|
}
|
|
|
|
void release_http_pack_request(struct http_pack_request *preq)
|
|
{
|
|
if (preq->packfile != NULL) {
|
|
fclose(preq->packfile);
|
|
preq->packfile = NULL;
|
|
preq->slot->local = NULL;
|
|
}
|
|
if (preq->range_header != NULL) {
|
|
curl_slist_free_all(preq->range_header);
|
|
preq->range_header = NULL;
|
|
}
|
|
preq->slot = NULL;
|
|
free(preq->url);
|
|
}
|
|
|
|
int finish_http_pack_request(struct http_pack_request *preq)
|
|
{
|
|
int ret;
|
|
struct packed_git **lst;
|
|
|
|
preq->target->pack_size = ftell(preq->packfile);
|
|
|
|
if (preq->packfile != NULL) {
|
|
fclose(preq->packfile);
|
|
preq->packfile = NULL;
|
|
preq->slot->local = NULL;
|
|
}
|
|
|
|
ret = move_temp_to_file(preq->tmpfile, preq->filename);
|
|
if (ret)
|
|
return ret;
|
|
|
|
lst = preq->lst;
|
|
while (*lst != preq->target)
|
|
lst = &((*lst)->next);
|
|
*lst = (*lst)->next;
|
|
|
|
if (verify_pack(preq->target))
|
|
return -1;
|
|
install_packed_git(preq->target);
|
|
|
|
return 0;
|
|
}
|
|
|
|
struct http_pack_request *new_http_pack_request(
|
|
struct packed_git *target, const char *base_url)
|
|
{
|
|
char *filename;
|
|
long prev_posn = 0;
|
|
char range[RANGE_HEADER_SIZE];
|
|
struct strbuf buf = STRBUF_INIT;
|
|
struct http_pack_request *preq;
|
|
|
|
preq = xmalloc(sizeof(*preq));
|
|
preq->target = target;
|
|
preq->range_header = NULL;
|
|
|
|
end_url_with_slash(&buf, base_url);
|
|
strbuf_addf(&buf, "objects/pack/pack-%s.pack",
|
|
sha1_to_hex(target->sha1));
|
|
preq->url = strbuf_detach(&buf, NULL);
|
|
|
|
filename = sha1_pack_name(target->sha1);
|
|
snprintf(preq->filename, sizeof(preq->filename), "%s", filename);
|
|
snprintf(preq->tmpfile, sizeof(preq->tmpfile), "%s.temp", filename);
|
|
preq->packfile = fopen(preq->tmpfile, "a");
|
|
if (!preq->packfile) {
|
|
error("Unable to open local file %s for pack",
|
|
preq->tmpfile);
|
|
goto abort;
|
|
}
|
|
|
|
preq->slot = get_active_slot();
|
|
preq->slot->local = preq->packfile;
|
|
curl_easy_setopt(preq->slot->curl, CURLOPT_FILE, 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,
|
|
no_pragma_header);
|
|
|
|
/*
|
|
* If there is data present from a previous transfer attempt,
|
|
* resume where it left off
|
|
*/
|
|
prev_posn = ftell(preq->packfile);
|
|
if (prev_posn>0) {
|
|
if (http_is_verbose)
|
|
fprintf(stderr,
|
|
"Resuming fetch of pack %s at byte %ld\n",
|
|
sha1_to_hex(target->sha1), prev_posn);
|
|
sprintf(range, "Range: bytes=%ld-", prev_posn);
|
|
preq->range_header = curl_slist_append(NULL, range);
|
|
curl_easy_setopt(preq->slot->curl, CURLOPT_HTTPHEADER,
|
|
preq->range_header);
|
|
}
|
|
|
|
return preq;
|
|
|
|
abort:
|
|
free(filename);
|
|
free(preq->url);
|
|
free(preq);
|
|
return NULL;
|
|
}
|
|
|
|
/* Helpers for fetching objects (loose) */
|
|
static size_t fwrite_sha1_file(void *ptr, size_t eltsize, size_t nmemb,
|
|
void *data)
|
|
{
|
|
unsigned char expn[4096];
|
|
size_t size = eltsize * nmemb;
|
|
int posn = 0;
|
|
struct http_object_request *freq =
|
|
(struct http_object_request *)data;
|
|
do {
|
|
ssize_t retval = xwrite(freq->localfile,
|
|
(char *) ptr + posn, size - posn);
|
|
if (retval < 0)
|
|
return posn;
|
|
posn += retval;
|
|
} while (posn < size);
|
|
|
|
freq->stream.avail_in = size;
|
|
freq->stream.next_in = ptr;
|
|
do {
|
|
freq->stream.next_out = expn;
|
|
freq->stream.avail_out = sizeof(expn);
|
|
freq->zret = git_inflate(&freq->stream, Z_SYNC_FLUSH);
|
|
git_SHA1_Update(&freq->c, expn,
|
|
sizeof(expn) - freq->stream.avail_out);
|
|
} while (freq->stream.avail_in && freq->zret == Z_OK);
|
|
data_received++;
|
|
return size;
|
|
}
|
|
|
|
struct http_object_request *new_http_object_request(const char *base_url,
|
|
unsigned char *sha1)
|
|
{
|
|
char *hex = sha1_to_hex(sha1);
|
|
char *filename;
|
|
char prevfile[PATH_MAX];
|
|
int prevlocal;
|
|
unsigned char prev_buf[PREV_BUF_SIZE];
|
|
ssize_t prev_read = 0;
|
|
long prev_posn = 0;
|
|
char range[RANGE_HEADER_SIZE];
|
|
struct curl_slist *range_header = NULL;
|
|
struct http_object_request *freq;
|
|
|
|
freq = xmalloc(sizeof(*freq));
|
|
hashcpy(freq->sha1, sha1);
|
|
freq->localfile = -1;
|
|
|
|
filename = sha1_file_name(sha1);
|
|
snprintf(freq->filename, sizeof(freq->filename), "%s", filename);
|
|
snprintf(freq->tmpfile, sizeof(freq->tmpfile),
|
|
"%s.temp", filename);
|
|
|
|
snprintf(prevfile, sizeof(prevfile), "%s.prev", filename);
|
|
unlink_or_warn(prevfile);
|
|
rename(freq->tmpfile, prevfile);
|
|
unlink_or_warn(freq->tmpfile);
|
|
|
|
if (freq->localfile != -1)
|
|
error("fd leakage in start: %d", freq->localfile);
|
|
freq->localfile = open(freq->tmpfile,
|
|
O_WRONLY | O_CREAT | O_EXCL, 0666);
|
|
/*
|
|
* This could have failed due to the "lazy directory creation";
|
|
* try to mkdir the last path component.
|
|
*/
|
|
if (freq->localfile < 0 && errno == ENOENT) {
|
|
char *dir = strrchr(freq->tmpfile, '/');
|
|
if (dir) {
|
|
*dir = 0;
|
|
mkdir(freq->tmpfile, 0777);
|
|
*dir = '/';
|
|
}
|
|
freq->localfile = open(freq->tmpfile,
|
|
O_WRONLY | O_CREAT | O_EXCL, 0666);
|
|
}
|
|
|
|
if (freq->localfile < 0) {
|
|
error("Couldn't create temporary file %s for %s: %s",
|
|
freq->tmpfile, freq->filename, strerror(errno));
|
|
goto abort;
|
|
}
|
|
|
|
memset(&freq->stream, 0, sizeof(freq->stream));
|
|
|
|
git_inflate_init(&freq->stream);
|
|
|
|
git_SHA1_Init(&freq->c);
|
|
|
|
freq->url = get_remote_object_url(base_url, hex, 0);
|
|
|
|
/*
|
|
* If a previous temp file is present, process what was already
|
|
* fetched.
|
|
*/
|
|
prevlocal = open(prevfile, O_RDONLY);
|
|
if (prevlocal != -1) {
|
|
do {
|
|
prev_read = xread(prevlocal, prev_buf, PREV_BUF_SIZE);
|
|
if (prev_read>0) {
|
|
if (fwrite_sha1_file(prev_buf,
|
|
1,
|
|
prev_read,
|
|
freq) == prev_read) {
|
|
prev_posn += prev_read;
|
|
} else {
|
|
prev_read = -1;
|
|
}
|
|
}
|
|
} while (prev_read > 0);
|
|
close(prevlocal);
|
|
}
|
|
unlink_or_warn(prevfile);
|
|
|
|
/*
|
|
* Reset inflate/SHA1 if there was an error reading the previous temp
|
|
* file; also rewind to the beginning of the local file.
|
|
*/
|
|
if (prev_read == -1) {
|
|
memset(&freq->stream, 0, sizeof(freq->stream));
|
|
git_inflate_init(&freq->stream);
|
|
git_SHA1_Init(&freq->c);
|
|
if (prev_posn>0) {
|
|
prev_posn = 0;
|
|
lseek(freq->localfile, 0, SEEK_SET);
|
|
if (ftruncate(freq->localfile, 0) < 0) {
|
|
error("Couldn't truncate temporary file %s for %s: %s",
|
|
freq->tmpfile, freq->filename, strerror(errno));
|
|
goto abort;
|
|
}
|
|
}
|
|
}
|
|
|
|
freq->slot = get_active_slot();
|
|
|
|
curl_easy_setopt(freq->slot->curl, CURLOPT_FILE, freq);
|
|
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_URL, freq->url);
|
|
curl_easy_setopt(freq->slot->curl, CURLOPT_HTTPHEADER, no_pragma_header);
|
|
|
|
/*
|
|
* If we have successfully processed data from a previous fetch
|
|
* attempt, only fetch the data we don't already have.
|
|
*/
|
|
if (prev_posn>0) {
|
|
if (http_is_verbose)
|
|
fprintf(stderr,
|
|
"Resuming fetch of object %s at byte %ld\n",
|
|
hex, prev_posn);
|
|
sprintf(range, "Range: bytes=%ld-", prev_posn);
|
|
range_header = curl_slist_append(range_header, range);
|
|
curl_easy_setopt(freq->slot->curl,
|
|
CURLOPT_HTTPHEADER, range_header);
|
|
}
|
|
|
|
return freq;
|
|
|
|
abort:
|
|
free(filename);
|
|
free(freq->url);
|
|
free(freq);
|
|
return NULL;
|
|
}
|
|
|
|
void process_http_object_request(struct http_object_request *freq)
|
|
{
|
|
if (freq->slot == NULL)
|
|
return;
|
|
freq->curl_result = freq->slot->curl_result;
|
|
freq->http_code = freq->slot->http_code;
|
|
freq->slot = NULL;
|
|
}
|
|
|
|
int finish_http_object_request(struct http_object_request *freq)
|
|
{
|
|
struct stat st;
|
|
|
|
close(freq->localfile);
|
|
freq->localfile = -1;
|
|
|
|
process_http_object_request(freq);
|
|
|
|
if (freq->http_code == 416) {
|
|
fprintf(stderr, "Warning: requested range invalid; we may already have all the data.\n");
|
|
} else if (freq->curl_result != CURLE_OK) {
|
|
if (stat(freq->tmpfile, &st) == 0)
|
|
if (st.st_size == 0)
|
|
unlink_or_warn(freq->tmpfile);
|
|
return -1;
|
|
}
|
|
|
|
git_inflate_end(&freq->stream);
|
|
git_SHA1_Final(freq->real_sha1, &freq->c);
|
|
if (freq->zret != Z_STREAM_END) {
|
|
unlink_or_warn(freq->tmpfile);
|
|
return -1;
|
|
}
|
|
if (hashcmp(freq->sha1, freq->real_sha1)) {
|
|
unlink_or_warn(freq->tmpfile);
|
|
return -1;
|
|
}
|
|
freq->rename =
|
|
move_temp_to_file(freq->tmpfile, freq->filename);
|
|
|
|
return freq->rename;
|
|
}
|
|
|
|
void abort_http_object_request(struct http_object_request *freq)
|
|
{
|
|
unlink_or_warn(freq->tmpfile);
|
|
|
|
release_http_object_request(freq);
|
|
}
|
|
|
|
void release_http_object_request(struct http_object_request *freq)
|
|
{
|
|
if (freq->localfile != -1) {
|
|
close(freq->localfile);
|
|
freq->localfile = -1;
|
|
}
|
|
if (freq->url != NULL) {
|
|
free(freq->url);
|
|
freq->url = NULL;
|
|
}
|
|
if (freq->slot != NULL) {
|
|
freq->slot->callback_func = NULL;
|
|
freq->slot->callback_data = NULL;
|
|
release_active_slot(freq->slot);
|
|
freq->slot = NULL;
|
|
}
|
|
}
|