2005-04-24 01:47:23 +00:00
|
|
|
#include "cache.h"
|
2018-03-23 17:21:10 +00:00
|
|
|
#include "repository.h"
|
2005-04-24 01:47:23 +00:00
|
|
|
#include "commit.h"
|
2007-09-11 03:02:45 +00:00
|
|
|
#include "walker.h"
|
2005-11-18 19:02:58 +00:00
|
|
|
#include "http.h"
|
2016-07-11 20:51:31 +00:00
|
|
|
#include "list.h"
|
http: respect protocol.*.allow=user for http-alternates
The http-walker may fetch the http-alternates (or
alternates) file from a remote in order to find more
objects. This should count as a "not from the user" use of
the protocol. But because we implement the redirection
ourselves and feed the new URL to curl, it will use the
CURLOPT_PROTOCOLS rules, not the more restrictive
CURLOPT_REDIR_PROTOCOLS.
The ideal solution would be for each curl request we make to
know whether or not is directly from the user or part of an
alternates redirect, and then set CURLOPT_PROTOCOLS as
appropriate. However, that would require plumbing that
information through all of the various layers of the http
code.
Instead, let's check the protocol at the source: when we are
parsing the remote http-alternates file. The only downside
is that if there's any mismatch between what protocol we
think it is versus what curl thinks it is, it could violate
the policy.
To address this, we'll make the parsing err on the picky
side, and only allow protocols that it can parse
definitively. So for example, you can't elude the "http"
policy by asking for "HTTP://", even though curl might
handle it; we would reject it as unknown. The only unsafe
case would be if you have a URL that starts with "http://"
but curl interprets as another protocol. That seems like an
unlikely failure mode (and we are still protected by our
base CURLOPT_PROTOCOL setting, so the worst you could do is
trigger one of https, ftp, or ftps).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-12-14 22:39:55 +00:00
|
|
|
#include "transport.h"
|
2017-08-18 22:20:34 +00:00
|
|
|
#include "packfile.h"
|
2018-03-23 17:20:59 +00:00
|
|
|
#include "object-store.h"
|
2005-10-15 18:10:46 +00:00
|
|
|
|
2011-03-16 07:08:34 +00:00
|
|
|
struct alt_base {
|
2007-03-28 09:46:15 +00:00
|
|
|
char *base;
|
2005-09-15 03:26:08 +00:00
|
|
|
int got_indices;
|
|
|
|
|
struct packed_git *packs;
|
|
|
|
|
struct alt_base *next;
|
|
|
|
|
};
|
|
|
|
|
|
2005-11-18 19:03:04 +00:00
|
|
|
enum object_request_state {
|
2005-10-11 06:22:01 +00:00
|
|
|
WAITING,
|
|
|
|
|
ABORTED,
|
|
|
|
|
ACTIVE,
|
2010-05-14 09:31:35 +00:00
|
|
|
COMPLETE
|
2005-10-11 06:22:01 +00:00
|
|
|
};
|
2005-04-24 01:47:23 +00:00
|
|
|
|
2011-03-16 07:08:34 +00:00
|
|
|
struct object_request {
|
2007-09-11 03:02:45 +00:00
|
|
|
struct walker *walker;
|
2018-03-12 02:27:31 +00:00
|
|
|
struct object_id oid;
|
2005-10-11 06:22:01 +00:00
|
|
|
struct alt_base *repo;
|
2005-11-18 19:03:04 +00:00
|
|
|
enum object_request_state state;
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
struct http_object_request *req;
|
2016-07-11 20:51:31 +00:00
|
|
|
struct list_head node;
|
2005-10-11 06:22:01 +00:00
|
|
|
};
|
|
|
|
|
|
2005-11-18 19:03:04 +00:00
|
|
|
struct alternates_request {
|
2007-09-11 03:02:45 +00:00
|
|
|
struct walker *walker;
|
2006-07-27 21:56:22 +00:00
|
|
|
const char *base;
|
2015-09-24 21:07:31 +00:00
|
|
|
struct strbuf *url;
|
2007-12-09 19:30:59 +00:00
|
|
|
struct strbuf *buffer;
|
2005-11-12 17:11:32 +00:00
|
|
|
struct active_request_slot *slot;
|
|
|
|
|
int http_specific;
|
|
|
|
|
};
|
|
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
struct walker_data {
|
|
|
|
|
const char *url;
|
|
|
|
|
int got_alternates;
|
|
|
|
|
struct alt_base *alt;
|
|
|
|
|
};
|
|
|
|
|
|
2016-07-11 20:51:31 +00:00
|
|
|
static LIST_HEAD(object_queue_head);
|
2005-10-13 17:49:53 +00:00
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
static void fetch_alternates(struct walker *walker, const char *base);
|
2005-10-11 06:22:01 +00:00
|
|
|
|
2005-11-18 19:02:58 +00:00
|
|
|
static void process_object_response(void *callback_data);
|
2005-10-11 06:22:01 +00:00
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
static void start_object_request(struct walker *walker,
|
|
|
|
|
struct object_request *obj_req)
|
2005-10-11 06:22:01 +00:00
|
|
|
{
|
|
|
|
|
struct active_request_slot *slot;
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
struct http_object_request *req;
|
2005-10-11 06:22:01 +00:00
|
|
|
|
2019-01-07 08:34:40 +00:00
|
|
|
req = new_http_object_request(obj_req->repo->base, &obj_req->oid);
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
if (req == NULL) {
|
2005-11-18 19:03:04 +00:00
|
|
|
obj_req->state = ABORTED;
|
2005-10-11 06:22:01 +00:00
|
|
|
return;
|
|
|
|
|
}
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
obj_req->req = req;
|
2005-10-11 06:22:01 +00:00
|
|
|
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
slot = req->slot;
|
2005-11-18 19:02:58 +00:00
|
|
|
slot->callback_func = process_object_response;
|
2005-11-18 19:03:04 +00:00
|
|
|
slot->callback_data = obj_req;
|
2005-10-11 06:22:01 +00:00
|
|
|
|
2005-10-11 06:22:01 +00:00
|
|
|
/* Try to get the request started, abort the request on error */
|
2005-11-18 19:03:04 +00:00
|
|
|
obj_req->state = ACTIVE;
|
2005-10-11 06:22:01 +00:00
|
|
|
if (!start_active_slot(slot)) {
|
2005-11-18 19:03:04 +00:00
|
|
|
obj_req->state = ABORTED;
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
release_http_object_request(req);
|
2005-11-18 19:03:04 +00:00
|
|
|
return;
|
2005-10-11 06:22:01 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2005-11-18 19:03:04 +00:00
|
|
|
static void finish_object_request(struct object_request *obj_req)
|
2005-10-11 06:22:01 +00:00
|
|
|
{
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
if (finish_http_object_request(obj_req->req))
|
2005-10-11 06:22:01 +00:00
|
|
|
return;
|
|
|
|
|
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
if (obj_req->req->rename == 0)
|
2018-03-12 02:27:31 +00:00
|
|
|
walker_say(obj_req->walker, "got %s\n", oid_to_hex(&obj_req->oid));
|
2005-10-11 06:22:01 +00:00
|
|
|
}
|
|
|
|
|
|
2005-11-18 19:02:58 +00:00
|
|
|
static void process_object_response(void *callback_data)
|
|
|
|
|
{
|
2005-11-18 19:03:04 +00:00
|
|
|
struct object_request *obj_req =
|
|
|
|
|
(struct object_request *)callback_data;
|
2007-09-11 03:02:45 +00:00
|
|
|
struct walker *walker = obj_req->walker;
|
|
|
|
|
struct walker_data *data = walker->data;
|
|
|
|
|
struct alt_base *alt = data->alt;
|
2005-11-18 19:02:58 +00:00
|
|
|
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
process_http_object_request(obj_req->req);
|
2005-11-18 19:03:04 +00:00
|
|
|
obj_req->state = COMPLETE;
|
2005-11-18 19:02:58 +00:00
|
|
|
|
http: normalize curl results for dumb loose and alternates fetches
If the dumb-http walker encounters a 404 when fetching a loose object,
it then looks at any http-alternates for the object. The 404 check is
implemented by missing_target(), which checks not only the http code,
but also that we got an http error from the CURLcode.
That broke when we stopped using CURLOPT_FAILONERROR in 17966c0a63
(http: avoid disconnecting on 404s for loose objects, 2016-07-11), since
our CURLcode will now be CURLE_OK. As a result, fetching over dumb-http
from a repository with alternates could result in Git printing "Unable
to find abcd1234..." and aborting.
We could probably fix this just by loosening missing_target(). However,
there's other code which looks at the curl result, and it would have to
be tweaked as well. Instead, let's just normalize the result the same
way the smart-http code does.
There's a similar case in processing the alternates (where we failover
from "info/http-alternates" to "info/alternates"). We'll give it the
same treatment.
After this patch, we should be hitting all code paths that need this
normalization (notably absent here is the http_pack_request path, but it
does not use FAILONERROR, nor missing_target()).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-03-24 12:09:46 +00:00
|
|
|
normalize_curl_result(&obj_req->req->curl_result,
|
|
|
|
|
obj_req->req->http_code,
|
|
|
|
|
obj_req->req->errorstr,
|
|
|
|
|
sizeof(obj_req->req->errorstr));
|
|
|
|
|
|
2005-11-18 19:02:58 +00:00
|
|
|
/* Use alternates if necessary */
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
if (missing_target(obj_req->req)) {
|
2007-09-11 03:02:45 +00:00
|
|
|
fetch_alternates(walker, alt->base);
|
2005-11-18 19:03:04 +00:00
|
|
|
if (obj_req->repo->next != NULL) {
|
|
|
|
|
obj_req->repo =
|
|
|
|
|
obj_req->repo->next;
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
release_http_object_request(obj_req->req);
|
2007-09-11 03:02:45 +00:00
|
|
|
start_object_request(walker, obj_req);
|
2005-11-18 19:02:58 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2005-11-18 19:03:04 +00:00
|
|
|
finish_object_request(obj_req);
|
2005-11-18 19:02:58 +00:00
|
|
|
}
|
|
|
|
|
|
2005-11-18 19:03:04 +00:00
|
|
|
static void release_object_request(struct object_request *obj_req)
|
2005-10-11 06:22:01 +00:00
|
|
|
{
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
if (obj_req->req !=NULL && obj_req->req->localfile != -1)
|
|
|
|
|
error("fd leakage in release: %d", obj_req->req->localfile);
|
2005-10-11 06:22:01 +00:00
|
|
|
|
2016-07-11 20:51:31 +00:00
|
|
|
list_del(&obj_req->node);
|
2005-11-18 19:03:04 +00:00
|
|
|
free(obj_req);
|
2005-10-11 06:22:01 +00:00
|
|
|
}
|
|
|
|
|
|
2005-10-11 06:22:01 +00:00
|
|
|
#ifdef USE_CURL_MULTI
|
2007-09-11 03:02:45 +00:00
|
|
|
static int fill_active_slot(struct walker *walker)
|
2005-10-11 06:22:01 +00:00
|
|
|
{
|
2007-09-11 03:02:28 +00:00
|
|
|
struct object_request *obj_req;
|
2016-07-11 20:51:31 +00:00
|
|
|
struct list_head *pos, *tmp, *head = &object_queue_head;
|
2005-10-11 06:22:01 +00:00
|
|
|
|
2016-07-11 20:51:31 +00:00
|
|
|
list_for_each_safe(pos, tmp, head) {
|
|
|
|
|
obj_req = list_entry(pos, struct object_request, node);
|
2005-11-18 19:03:04 +00:00
|
|
|
if (obj_req->state == WAITING) {
|
2019-01-07 08:37:54 +00:00
|
|
|
if (has_object_file(&obj_req->oid))
|
2006-02-01 11:44:28 +00:00
|
|
|
obj_req->state = COMPLETE;
|
2007-09-11 03:02:28 +00:00
|
|
|
else {
|
2007-09-11 03:02:45 +00:00
|
|
|
start_object_request(walker, obj_req);
|
2007-09-11 03:02:28 +00:00
|
|
|
return 1;
|
|
|
|
|
}
|
2005-10-21 19:06:10 +00:00
|
|
|
}
|
2006-02-01 02:15:51 +00:00
|
|
|
}
|
2007-09-11 03:02:28 +00:00
|
|
|
return 0;
|
2005-10-11 06:22:01 +00:00
|
|
|
}
|
2005-10-11 06:22:01 +00:00
|
|
|
#endif
|
2005-10-11 06:22:01 +00:00
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
static void prefetch(struct walker *walker, unsigned char *sha1)
|
2005-10-11 06:22:01 +00:00
|
|
|
{
|
2005-11-18 19:03:04 +00:00
|
|
|
struct object_request *newreq;
|
2007-09-11 03:02:45 +00:00
|
|
|
struct walker_data *data = walker->data;
|
2005-10-11 06:22:01 +00:00
|
|
|
|
|
|
|
|
newreq = xmalloc(sizeof(*newreq));
|
2007-09-11 03:02:45 +00:00
|
|
|
newreq->walker = walker;
|
2018-03-12 02:27:31 +00:00
|
|
|
hashcpy(newreq->oid.hash, sha1);
|
2007-09-11 03:02:45 +00:00
|
|
|
newreq->repo = data->alt;
|
2005-10-11 06:22:01 +00:00
|
|
|
newreq->state = WAITING;
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
newreq->req = NULL;
|
2005-10-11 06:22:01 +00:00
|
|
|
|
2009-06-06 08:43:41 +00:00
|
|
|
http_is_verbose = walker->get_verbosely;
|
2016-07-11 20:51:31 +00:00
|
|
|
list_add_tail(&newreq->node, &object_queue_head);
|
2005-11-18 19:02:58 +00:00
|
|
|
|
2005-10-11 06:22:01 +00:00
|
|
|
#ifdef USE_CURL_MULTI
|
2005-11-18 19:02:58 +00:00
|
|
|
fill_active_slots();
|
|
|
|
|
step_active_slots();
|
2005-10-11 06:22:01 +00:00
|
|
|
#endif
|
2005-10-11 06:22:01 +00:00
|
|
|
}
|
|
|
|
|
|
http: respect protocol.*.allow=user for http-alternates
The http-walker may fetch the http-alternates (or
alternates) file from a remote in order to find more
objects. This should count as a "not from the user" use of
the protocol. But because we implement the redirection
ourselves and feed the new URL to curl, it will use the
CURLOPT_PROTOCOLS rules, not the more restrictive
CURLOPT_REDIR_PROTOCOLS.
The ideal solution would be for each curl request we make to
know whether or not is directly from the user or part of an
alternates redirect, and then set CURLOPT_PROTOCOLS as
appropriate. However, that would require plumbing that
information through all of the various layers of the http
code.
Instead, let's check the protocol at the source: when we are
parsing the remote http-alternates file. The only downside
is that if there's any mismatch between what protocol we
think it is versus what curl thinks it is, it could violate
the policy.
To address this, we'll make the parsing err on the picky
side, and only allow protocols that it can parse
definitively. So for example, you can't elude the "http"
policy by asking for "HTTP://", even though curl might
handle it; we would reject it as unknown. The only unsafe
case would be if you have a URL that starts with "http://"
but curl interprets as another protocol. That seems like an
unlikely failure mode (and we are still protected by our
base CURLOPT_PROTOCOL setting, so the worst you could do is
trigger one of https, ftp, or ftps).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-12-14 22:39:55 +00:00
|
|
|
static int is_alternate_allowed(const char *url)
|
|
|
|
|
{
|
|
|
|
|
const char *protocols[] = {
|
|
|
|
|
"http", "https", "ftp", "ftps"
|
|
|
|
|
};
|
|
|
|
|
int i;
|
|
|
|
|
|
2017-03-04 08:36:45 +00:00
|
|
|
if (http_follow_config != HTTP_FOLLOW_ALWAYS) {
|
|
|
|
|
warning("alternate disabled by http.followRedirects: %s", url);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
http: respect protocol.*.allow=user for http-alternates
The http-walker may fetch the http-alternates (or
alternates) file from a remote in order to find more
objects. This should count as a "not from the user" use of
the protocol. But because we implement the redirection
ourselves and feed the new URL to curl, it will use the
CURLOPT_PROTOCOLS rules, not the more restrictive
CURLOPT_REDIR_PROTOCOLS.
The ideal solution would be for each curl request we make to
know whether or not is directly from the user or part of an
alternates redirect, and then set CURLOPT_PROTOCOLS as
appropriate. However, that would require plumbing that
information through all of the various layers of the http
code.
Instead, let's check the protocol at the source: when we are
parsing the remote http-alternates file. The only downside
is that if there's any mismatch between what protocol we
think it is versus what curl thinks it is, it could violate
the policy.
To address this, we'll make the parsing err on the picky
side, and only allow protocols that it can parse
definitively. So for example, you can't elude the "http"
policy by asking for "HTTP://", even though curl might
handle it; we would reject it as unknown. The only unsafe
case would be if you have a URL that starts with "http://"
but curl interprets as another protocol. That seems like an
unlikely failure mode (and we are still protected by our
base CURLOPT_PROTOCOL setting, so the worst you could do is
trigger one of https, ftp, or ftps).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-12-14 22:39:55 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(protocols); i++) {
|
|
|
|
|
const char *end;
|
|
|
|
|
if (skip_prefix(url, protocols[i], &end) &&
|
|
|
|
|
starts_with(end, "://"))
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (i >= ARRAY_SIZE(protocols)) {
|
|
|
|
|
warning("ignoring alternate with unknown protocol: %s", url);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
if (!is_transport_allowed(protocols[i], 0)) {
|
|
|
|
|
warning("ignoring alternate with restricted protocol: %s", url);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2005-11-18 19:03:04 +00:00
|
|
|
static void process_alternates_response(void *callback_data)
|
2005-09-15 03:26:08 +00:00
|
|
|
{
|
2005-11-18 19:03:04 +00:00
|
|
|
struct alternates_request *alt_req =
|
|
|
|
|
(struct alternates_request *)callback_data;
|
2007-09-11 03:02:45 +00:00
|
|
|
struct walker *walker = alt_req->walker;
|
|
|
|
|
struct walker_data *cdata = walker->data;
|
2005-11-12 17:11:32 +00:00
|
|
|
struct active_request_slot *slot = alt_req->slot;
|
2007-09-11 03:02:45 +00:00
|
|
|
struct alt_base *tail = cdata->alt;
|
2006-07-27 21:56:22 +00:00
|
|
|
const char *base = alt_req->base;
|
2011-05-03 15:47:27 +00:00
|
|
|
const char null_byte = '\0';
|
2005-11-12 17:11:32 +00:00
|
|
|
char *data;
|
|
|
|
|
int i = 0;
|
2005-10-11 06:22:01 +00:00
|
|
|
|
http: normalize curl results for dumb loose and alternates fetches
If the dumb-http walker encounters a 404 when fetching a loose object,
it then looks at any http-alternates for the object. The 404 check is
implemented by missing_target(), which checks not only the http code,
but also that we got an http error from the CURLcode.
That broke when we stopped using CURLOPT_FAILONERROR in 17966c0a63
(http: avoid disconnecting on 404s for loose objects, 2016-07-11), since
our CURLcode will now be CURLE_OK. As a result, fetching over dumb-http
from a repository with alternates could result in Git printing "Unable
to find abcd1234..." and aborting.
We could probably fix this just by loosening missing_target(). However,
there's other code which looks at the curl result, and it would have to
be tweaked as well. Instead, let's just normalize the result the same
way the smart-http code does.
There's a similar case in processing the alternates (where we failover
from "info/http-alternates" to "info/alternates"). We'll give it the
same treatment.
After this patch, we should be hitting all code paths that need this
normalization (notably absent here is the http_pack_request path, but it
does not use FAILONERROR, nor missing_target()).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-03-24 12:09:46 +00:00
|
|
|
normalize_curl_result(&slot->curl_result, slot->http_code,
|
|
|
|
|
curl_errorstr, sizeof(curl_errorstr));
|
|
|
|
|
|
2005-11-12 17:11:32 +00:00
|
|
|
if (alt_req->http_specific) {
|
|
|
|
|
if (slot->curl_result != CURLE_OK ||
|
2007-12-09 19:30:59 +00:00
|
|
|
!alt_req->buffer->len) {
|
2005-11-12 17:11:32 +00:00
|
|
|
|
|
|
|
|
/* Try reusing the slot to get non-http alternates */
|
|
|
|
|
alt_req->http_specific = 0;
|
2015-09-24 21:07:31 +00:00
|
|
|
strbuf_reset(alt_req->url);
|
|
|
|
|
strbuf_addf(alt_req->url, "%s/objects/info/alternates",
|
|
|
|
|
base);
|
2005-11-12 17:11:32 +00:00
|
|
|
curl_easy_setopt(slot->curl, CURLOPT_URL,
|
2015-09-24 21:07:31 +00:00
|
|
|
alt_req->url->buf);
|
2005-11-12 17:11:32 +00:00
|
|
|
active_requests++;
|
|
|
|
|
slot->in_use = 1;
|
2006-03-15 16:59:52 +00:00
|
|
|
if (slot->finished != NULL)
|
|
|
|
|
(*slot->finished) = 0;
|
2006-02-01 11:44:39 +00:00
|
|
|
if (!start_active_slot(slot)) {
|
2007-09-11 03:02:45 +00:00
|
|
|
cdata->got_alternates = -1;
|
2005-11-18 19:02:58 +00:00
|
|
|
slot->in_use = 0;
|
2006-03-15 16:59:52 +00:00
|
|
|
if (slot->finished != NULL)
|
|
|
|
|
(*slot->finished) = 1;
|
2005-10-11 06:22:01 +00:00
|
|
|
}
|
2006-02-01 11:44:39 +00:00
|
|
|
return;
|
2005-09-15 03:26:08 +00:00
|
|
|
}
|
2005-11-12 17:11:32 +00:00
|
|
|
} else if (slot->curl_result != CURLE_OK) {
|
2006-09-16 17:58:20 +00:00
|
|
|
if (!missing_target(slot)) {
|
2007-09-11 03:02:45 +00:00
|
|
|
cdata->got_alternates = -1;
|
2005-11-12 17:11:32 +00:00
|
|
|
return;
|
|
|
|
|
}
|
2005-09-15 03:26:08 +00:00
|
|
|
}
|
|
|
|
|
|
2011-05-03 15:47:27 +00:00
|
|
|
fwrite_buffer((char *)&null_byte, 1, 1, alt_req->buffer);
|
2007-12-09 19:30:59 +00:00
|
|
|
alt_req->buffer->len--;
|
|
|
|
|
data = alt_req->buffer->buf;
|
2005-09-18 18:14:19 +00:00
|
|
|
|
2007-12-09 19:30:59 +00:00
|
|
|
while (i < alt_req->buffer->len) {
|
2005-09-15 03:26:08 +00:00
|
|
|
int posn = i;
|
2007-12-09 19:30:59 +00:00
|
|
|
while (posn < alt_req->buffer->len && data[posn] != '\n')
|
2005-09-15 03:26:08 +00:00
|
|
|
posn++;
|
|
|
|
|
if (data[posn] == '\n') {
|
2005-09-18 18:14:19 +00:00
|
|
|
int okay = 0;
|
|
|
|
|
int serverlen = 0;
|
|
|
|
|
struct alt_base *newalt;
|
2005-09-15 03:26:08 +00:00
|
|
|
if (data[i] == '/') {
|
2009-06-06 08:43:33 +00:00
|
|
|
/*
|
|
|
|
|
* This counts
|
2006-09-13 06:53:27 +00:00
|
|
|
* http://git.host/pub/scm/linux.git/
|
|
|
|
|
* -----------here^
|
|
|
|
|
* so memcpy(dst, base, serverlen) will
|
|
|
|
|
* copy up to "...git.host".
|
|
|
|
|
*/
|
|
|
|
|
const char *colon_ss = strstr(base,"://");
|
|
|
|
|
if (colon_ss) {
|
|
|
|
|
serverlen = (strchr(colon_ss + 3, '/')
|
|
|
|
|
- base);
|
|
|
|
|
okay = 1;
|
|
|
|
|
}
|
2005-09-18 18:14:19 +00:00
|
|
|
} else if (!memcmp(data + i, "../", 3)) {
|
2009-06-06 08:43:33 +00:00
|
|
|
/*
|
|
|
|
|
* Relative URL; chop the corresponding
|
2006-09-13 06:53:27 +00:00
|
|
|
* number of subpath from base (and ../
|
|
|
|
|
* from data), and concatenate the result.
|
|
|
|
|
*
|
|
|
|
|
* The code first drops ../ from data, and
|
|
|
|
|
* then drops one ../ from data and one path
|
|
|
|
|
* from base. IOW, one extra ../ is dropped
|
|
|
|
|
* from data than path is dropped from base.
|
|
|
|
|
*
|
|
|
|
|
* This is not wrong. The alternate in
|
|
|
|
|
* http://git.host/pub/scm/linux.git/
|
|
|
|
|
* to borrow from
|
|
|
|
|
* http://git.host/pub/scm/linus.git/
|
|
|
|
|
* is ../../linus.git/objects/. You need
|
|
|
|
|
* two ../../ to borrow from your direct
|
|
|
|
|
* neighbour.
|
|
|
|
|
*/
|
2005-09-18 18:14:19 +00:00
|
|
|
i += 3;
|
|
|
|
|
serverlen = strlen(base);
|
2006-02-01 02:15:51 +00:00
|
|
|
while (i + 2 < posn &&
|
2005-09-18 18:14:19 +00:00
|
|
|
!memcmp(data + i, "../", 3)) {
|
|
|
|
|
do {
|
|
|
|
|
serverlen--;
|
|
|
|
|
} while (serverlen &&
|
|
|
|
|
base[serverlen - 1] != '/');
|
|
|
|
|
i += 3;
|
|
|
|
|
}
|
2006-07-10 06:57:51 +00:00
|
|
|
/* If the server got removed, give up. */
|
2006-02-01 02:15:51 +00:00
|
|
|
okay = strchr(base, ':') - base + 3 <
|
2009-06-06 08:43:33 +00:00
|
|
|
serverlen;
|
2005-11-12 17:11:32 +00:00
|
|
|
} else if (alt_req->http_specific) {
|
2005-09-18 18:14:19 +00:00
|
|
|
char *colon = strchr(data + i, ':');
|
|
|
|
|
char *slash = strchr(data + i, '/');
|
|
|
|
|
if (colon && slash && colon < data + posn &&
|
|
|
|
|
slash < data + posn && colon < slash) {
|
|
|
|
|
okay = 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (okay) {
|
2014-08-30 15:55:45 +00:00
|
|
|
struct strbuf target = STRBUF_INIT;
|
|
|
|
|
strbuf_add(&target, base, serverlen);
|
2017-03-13 14:04:45 +00:00
|
|
|
strbuf_add(&target, data + i, posn - i);
|
|
|
|
|
if (!strbuf_strip_suffix(&target, "objects")) {
|
|
|
|
|
warning("ignoring alternate that does"
|
|
|
|
|
" not end in 'objects': %s",
|
|
|
|
|
target.buf);
|
|
|
|
|
strbuf_release(&target);
|
|
|
|
|
} else if (is_alternate_allowed(target.buf)) {
|
http: respect protocol.*.allow=user for http-alternates
The http-walker may fetch the http-alternates (or
alternates) file from a remote in order to find more
objects. This should count as a "not from the user" use of
the protocol. But because we implement the redirection
ourselves and feed the new URL to curl, it will use the
CURLOPT_PROTOCOLS rules, not the more restrictive
CURLOPT_REDIR_PROTOCOLS.
The ideal solution would be for each curl request we make to
know whether or not is directly from the user or part of an
alternates redirect, and then set CURLOPT_PROTOCOLS as
appropriate. However, that would require plumbing that
information through all of the various layers of the http
code.
Instead, let's check the protocol at the source: when we are
parsing the remote http-alternates file. The only downside
is that if there's any mismatch between what protocol we
think it is versus what curl thinks it is, it could violate
the policy.
To address this, we'll make the parsing err on the picky
side, and only allow protocols that it can parse
definitively. So for example, you can't elude the "http"
policy by asking for "HTTP://", even though curl might
handle it; we would reject it as unknown. The only unsafe
case would be if you have a URL that starts with "http://"
but curl interprets as another protocol. That seems like an
unlikely failure mode (and we are still protected by our
base CURLOPT_PROTOCOL setting, so the worst you could do is
trigger one of https, ftp, or ftps).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-12-14 22:39:55 +00:00
|
|
|
warning("adding alternate object store: %s",
|
|
|
|
|
target.buf);
|
|
|
|
|
newalt = xmalloc(sizeof(*newalt));
|
|
|
|
|
newalt->next = NULL;
|
|
|
|
|
newalt->base = strbuf_detach(&target, NULL);
|
|
|
|
|
newalt->got_indices = 0;
|
|
|
|
|
newalt->packs = NULL;
|
|
|
|
|
|
|
|
|
|
while (tail->next != NULL)
|
|
|
|
|
tail = tail->next;
|
|
|
|
|
tail->next = newalt;
|
2017-03-04 01:50:16 +00:00
|
|
|
} else {
|
|
|
|
|
strbuf_release(&target);
|
http: respect protocol.*.allow=user for http-alternates
The http-walker may fetch the http-alternates (or
alternates) file from a remote in order to find more
objects. This should count as a "not from the user" use of
the protocol. But because we implement the redirection
ourselves and feed the new URL to curl, it will use the
CURLOPT_PROTOCOLS rules, not the more restrictive
CURLOPT_REDIR_PROTOCOLS.
The ideal solution would be for each curl request we make to
know whether or not is directly from the user or part of an
alternates redirect, and then set CURLOPT_PROTOCOLS as
appropriate. However, that would require plumbing that
information through all of the various layers of the http
code.
Instead, let's check the protocol at the source: when we are
parsing the remote http-alternates file. The only downside
is that if there's any mismatch between what protocol we
think it is versus what curl thinks it is, it could violate
the policy.
To address this, we'll make the parsing err on the picky
side, and only allow protocols that it can parse
definitively. So for example, you can't elude the "http"
policy by asking for "HTTP://", even though curl might
handle it; we would reject it as unknown. The only unsafe
case would be if you have a URL that starts with "http://"
but curl interprets as another protocol. That seems like an
unlikely failure mode (and we are still protected by our
base CURLOPT_PROTOCOL setting, so the worst you could do is
trigger one of https, ftp, or ftps).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-12-14 22:39:55 +00:00
|
|
|
}
|
2005-09-15 03:26:08 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
i = posn + 1;
|
|
|
|
|
}
|
2005-10-13 17:49:53 +00:00
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
cdata->got_alternates = 1;
|
2005-11-12 17:11:32 +00:00
|
|
|
}
|
|
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
static void fetch_alternates(struct walker *walker, const char *base)
|
2005-11-12 17:11:32 +00:00
|
|
|
{
|
2007-12-09 19:30:59 +00:00
|
|
|
struct strbuf buffer = STRBUF_INIT;
|
2015-09-24 21:07:31 +00:00
|
|
|
struct strbuf url = STRBUF_INIT;
|
2005-11-12 17:11:32 +00:00
|
|
|
struct active_request_slot *slot;
|
2006-02-01 02:00:37 +00:00
|
|
|
struct alternates_request alt_req;
|
2007-09-11 03:02:45 +00:00
|
|
|
struct walker_data *cdata = walker->data;
|
2005-11-12 17:11:32 +00:00
|
|
|
|
2009-06-06 08:43:33 +00:00
|
|
|
/*
|
|
|
|
|
* If another request has already started fetching alternates,
|
|
|
|
|
* wait for them to arrive and return to processing this request's
|
|
|
|
|
* curl message
|
|
|
|
|
*/
|
2005-11-18 19:02:58 +00:00
|
|
|
#ifdef USE_CURL_MULTI
|
2007-09-11 03:02:45 +00:00
|
|
|
while (cdata->got_alternates == 0) {
|
2005-11-18 19:02:58 +00:00
|
|
|
step_active_slots();
|
2005-11-12 17:11:32 +00:00
|
|
|
}
|
2005-11-18 19:02:58 +00:00
|
|
|
#endif
|
2005-11-12 17:11:32 +00:00
|
|
|
|
|
|
|
|
/* Nothing to do if they've already been fetched */
|
2007-09-11 03:02:45 +00:00
|
|
|
if (cdata->got_alternates == 1)
|
2005-11-12 17:11:32 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* Start the fetch */
|
2007-09-11 03:02:45 +00:00
|
|
|
cdata->got_alternates = 0;
|
2005-11-12 17:11:32 +00:00
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
if (walker->get_verbosely)
|
2005-11-12 17:11:32 +00:00
|
|
|
fprintf(stderr, "Getting alternates list for %s\n", base);
|
2006-02-01 02:15:51 +00:00
|
|
|
|
2015-09-24 21:07:31 +00:00
|
|
|
strbuf_addf(&url, "%s/objects/info/http-alternates", base);
|
2005-11-12 17:11:32 +00:00
|
|
|
|
2009-06-06 08:43:33 +00:00
|
|
|
/*
|
|
|
|
|
* Use a callback to process the result, since another request
|
|
|
|
|
* may fail and need to have alternates loaded before continuing
|
|
|
|
|
*/
|
2005-11-12 17:11:32 +00:00
|
|
|
slot = get_active_slot();
|
2005-11-18 19:03:04 +00:00
|
|
|
slot->callback_func = process_alternates_response;
|
2007-09-11 03:02:45 +00:00
|
|
|
alt_req.walker = walker;
|
2005-11-12 17:11:32 +00:00
|
|
|
slot->callback_data = &alt_req;
|
|
|
|
|
|
|
|
|
|
curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
|
2005-11-18 19:02:58 +00:00
|
|
|
curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
|
2015-09-24 21:07:31 +00:00
|
|
|
curl_easy_setopt(slot->curl, CURLOPT_URL, url.buf);
|
2005-11-12 17:11:32 +00:00
|
|
|
|
|
|
|
|
alt_req.base = base;
|
2015-09-24 21:07:31 +00:00
|
|
|
alt_req.url = &url;
|
2005-11-12 17:11:32 +00:00
|
|
|
alt_req.buffer = &buffer;
|
|
|
|
|
alt_req.http_specific = 1;
|
|
|
|
|
alt_req.slot = slot;
|
|
|
|
|
|
|
|
|
|
if (start_active_slot(slot))
|
|
|
|
|
run_active_slot(slot);
|
|
|
|
|
else
|
2007-09-11 03:02:45 +00:00
|
|
|
cdata->got_alternates = -1;
|
2005-11-12 17:11:32 +00:00
|
|
|
|
2007-12-09 19:30:59 +00:00
|
|
|
strbuf_release(&buffer);
|
2015-09-24 21:07:31 +00:00
|
|
|
strbuf_release(&url);
|
2005-09-15 03:26:08 +00:00
|
|
|
}
|
|
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
static int fetch_indices(struct walker *walker, struct alt_base *repo)
|
2005-08-01 00:54:17 +00:00
|
|
|
{
|
2009-06-06 08:43:59 +00:00
|
|
|
int ret;
|
2005-10-11 06:22:01 +00:00
|
|
|
|
2005-09-15 03:26:08 +00:00
|
|
|
if (repo->got_indices)
|
2005-08-01 00:54:17 +00:00
|
|
|
return 0;
|
|
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
if (walker->get_verbosely)
|
2005-11-12 00:49:59 +00:00
|
|
|
fprintf(stderr, "Getting pack list for %s\n", repo->base);
|
2006-02-01 02:15:51 +00:00
|
|
|
|
2009-06-06 08:43:59 +00:00
|
|
|
switch (http_get_info_packs(repo->base, &repo->packs)) {
|
|
|
|
|
case HTTP_OK:
|
|
|
|
|
case HTTP_MISSING_TARGET:
|
|
|
|
|
repo->got_indices = 1;
|
|
|
|
|
ret = 0;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
2005-11-18 19:03:11 +00:00
|
|
|
repo->got_indices = 0;
|
2009-06-06 08:43:59 +00:00
|
|
|
ret = -1;
|
2005-09-15 03:26:08 +00:00
|
|
|
}
|
2005-08-01 00:54:17 +00:00
|
|
|
|
2007-12-10 21:36:11 +00:00
|
|
|
return ret;
|
2005-08-01 00:54:17 +00:00
|
|
|
}
|
|
|
|
|
|
2012-09-09 06:19:38 +00:00
|
|
|
static int http_fetch_pack(struct walker *walker, struct alt_base *repo, unsigned char *sha1)
|
2005-08-01 00:54:17 +00:00
|
|
|
{
|
|
|
|
|
struct packed_git *target;
|
2005-09-28 17:14:04 +00:00
|
|
|
int ret;
|
2006-02-01 02:00:37 +00:00
|
|
|
struct slot_results results;
|
2009-06-06 08:44:01 +00:00
|
|
|
struct http_pack_request *preq;
|
2005-08-01 00:54:17 +00:00
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
if (fetch_indices(walker, repo))
|
2005-08-01 00:54:17 +00:00
|
|
|
return -1;
|
2005-09-15 03:26:08 +00:00
|
|
|
target = find_sha1_pack(sha1, repo->packs);
|
2005-08-01 00:54:17 +00:00
|
|
|
if (!target)
|
2005-09-15 03:26:08 +00:00
|
|
|
return -1;
|
http: refactor finish_http_pack_request()
finish_http_pack_request() does multiple tasks, including some
housekeeping on a struct packed_git - (1) closing its index, (2)
removing it from a list, and (3) installing it. These concerns are
independent of fetching a pack through HTTP: they are there only because
(1) the calling code opens the pack's index before deciding to fetch it,
(2) the calling code maintains a list of packfiles that can be fetched,
and (3) the calling code fetches it in order to make use of its objects
in the same process.
In preparation for a subsequent commit, which adds a feature that does
not need any of this housekeeping, remove (1), (2), and (3) from
finish_http_pack_request(). (2) and (3) are now done by a helper
function, and (1) is the responsibility of the caller (in this patch,
done closer to the point where the pack index is opened).
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-06-10 20:57:16 +00:00
|
|
|
close_pack_index(target);
|
2005-08-01 00:54:17 +00:00
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
if (walker->get_verbosely) {
|
2005-08-01 00:54:17 +00:00
|
|
|
fprintf(stderr, "Getting pack %s\n",
|
2019-02-19 00:05:12 +00:00
|
|
|
hash_to_hex(target->hash));
|
2005-08-01 00:54:17 +00:00
|
|
|
fprintf(stderr, " which contains %s\n",
|
2019-02-19 00:05:12 +00:00
|
|
|
hash_to_hex(sha1));
|
2005-08-01 00:54:17 +00:00
|
|
|
}
|
|
|
|
|
|
http: refactor finish_http_pack_request()
finish_http_pack_request() does multiple tasks, including some
housekeeping on a struct packed_git - (1) closing its index, (2)
removing it from a list, and (3) installing it. These concerns are
independent of fetching a pack through HTTP: they are there only because
(1) the calling code opens the pack's index before deciding to fetch it,
(2) the calling code maintains a list of packfiles that can be fetched,
and (3) the calling code fetches it in order to make use of its objects
in the same process.
In preparation for a subsequent commit, which adds a feature that does
not need any of this housekeeping, remove (1), (2), and (3) from
finish_http_pack_request(). (2) and (3) are now done by a helper
function, and (1) is the responsibility of the caller (in this patch,
done closer to the point where the pack index is opened).
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-06-10 20:57:16 +00:00
|
|
|
preq = new_http_pack_request(target->hash, repo->base);
|
2009-06-06 08:44:01 +00:00
|
|
|
if (preq == NULL)
|
|
|
|
|
goto abort;
|
|
|
|
|
preq->slot->results = &results;
|
2005-08-01 00:54:17 +00:00
|
|
|
|
2009-06-06 08:44:01 +00:00
|
|
|
if (start_active_slot(preq->slot)) {
|
|
|
|
|
run_active_slot(preq->slot);
|
2006-01-31 19:06:55 +00:00
|
|
|
if (results.curl_result != CURLE_OK) {
|
2009-06-06 08:44:01 +00:00
|
|
|
error("Unable to get pack file %s\n%s", preq->url,
|
|
|
|
|
curl_errorstr);
|
|
|
|
|
goto abort;
|
2005-10-11 06:22:01 +00:00
|
|
|
}
|
|
|
|
|
} else {
|
2009-06-06 08:44:01 +00:00
|
|
|
error("Unable to start request");
|
|
|
|
|
goto abort;
|
2005-08-01 00:54:17 +00:00
|
|
|
}
|
|
|
|
|
|
2009-06-06 08:44:01 +00:00
|
|
|
ret = finish_http_pack_request(preq);
|
|
|
|
|
release_http_pack_request(preq);
|
2005-09-28 17:14:04 +00:00
|
|
|
if (ret)
|
2005-10-11 06:22:01 +00:00
|
|
|
return ret;
|
http: refactor finish_http_pack_request()
finish_http_pack_request() does multiple tasks, including some
housekeeping on a struct packed_git - (1) closing its index, (2)
removing it from a list, and (3) installing it. These concerns are
independent of fetching a pack through HTTP: they are there only because
(1) the calling code opens the pack's index before deciding to fetch it,
(2) the calling code maintains a list of packfiles that can be fetched,
and (3) the calling code fetches it in order to make use of its objects
in the same process.
In preparation for a subsequent commit, which adds a feature that does
not need any of this housekeeping, remove (1), (2), and (3) from
finish_http_pack_request(). (2) and (3) are now done by a helper
function, and (1) is the responsibility of the caller (in this patch,
done closer to the point where the pack index is opened).
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-06-10 20:57:16 +00:00
|
|
|
http_install_packfile(target, &repo->packs);
|
2005-09-28 17:14:04 +00:00
|
|
|
|
2005-08-01 00:54:17 +00:00
|
|
|
return 0;
|
2009-06-06 08:44:01 +00:00
|
|
|
|
|
|
|
|
abort:
|
|
|
|
|
return -1;
|
2005-08-01 00:54:17 +00:00
|
|
|
}
|
|
|
|
|
|
2006-02-07 10:07:39 +00:00
|
|
|
static void abort_object_request(struct object_request *obj_req)
|
|
|
|
|
{
|
|
|
|
|
release_object_request(obj_req);
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-19 00:05:12 +00:00
|
|
|
static int fetch_object(struct walker *walker, unsigned char *hash)
|
2005-04-24 01:47:23 +00:00
|
|
|
{
|
2019-02-19 00:05:12 +00:00
|
|
|
char *hex = hash_to_hex(hash);
|
2005-11-18 19:02:58 +00:00
|
|
|
int ret = 0;
|
2016-07-11 20:51:31 +00:00
|
|
|
struct object_request *obj_req = NULL;
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
struct http_object_request *req;
|
2016-07-11 20:51:31 +00:00
|
|
|
struct list_head *pos, *head = &object_queue_head;
|
2005-10-11 06:22:01 +00:00
|
|
|
|
2016-07-11 20:51:31 +00:00
|
|
|
list_for_each(pos, head) {
|
|
|
|
|
obj_req = list_entry(pos, struct object_request, node);
|
2019-02-19 00:05:12 +00:00
|
|
|
if (hasheq(obj_req->oid.hash, hash))
|
2016-07-11 20:51:31 +00:00
|
|
|
break;
|
|
|
|
|
}
|
2005-11-18 19:03:04 +00:00
|
|
|
if (obj_req == NULL)
|
2005-10-11 06:22:01 +00:00
|
|
|
return error("Couldn't find request for %s in the queue", hex);
|
|
|
|
|
|
2019-01-07 08:37:54 +00:00
|
|
|
if (has_object_file(&obj_req->oid)) {
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
if (obj_req->req != NULL)
|
|
|
|
|
abort_http_object_request(obj_req->req);
|
2006-02-07 10:07:39 +00:00
|
|
|
abort_object_request(obj_req);
|
2005-10-11 06:22:01 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2005-10-11 06:22:01 +00:00
|
|
|
#ifdef USE_CURL_MULTI
|
2009-06-06 08:43:33 +00:00
|
|
|
while (obj_req->state == WAITING)
|
2005-11-18 19:02:58 +00:00
|
|
|
step_active_slots();
|
2005-10-11 06:22:01 +00:00
|
|
|
#else
|
2007-09-11 03:02:45 +00:00
|
|
|
start_object_request(walker, obj_req);
|
2005-10-11 06:22:01 +00:00
|
|
|
#endif
|
2005-04-24 01:47:23 +00:00
|
|
|
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
/*
|
|
|
|
|
* obj_req->req might change when fetching alternates in the callback
|
|
|
|
|
* process_object_response; therefore, the "shortcut" variable, req,
|
|
|
|
|
* is used only after we're done with slots.
|
|
|
|
|
*/
|
2009-06-06 08:43:33 +00:00
|
|
|
while (obj_req->state == ACTIVE)
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
run_active_slot(obj_req->req->slot);
|
|
|
|
|
|
|
|
|
|
req = obj_req->req;
|
2009-06-06 08:43:33 +00:00
|
|
|
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
if (req->localfile != -1) {
|
|
|
|
|
close(req->localfile);
|
|
|
|
|
req->localfile = -1;
|
2005-11-11 23:55:16 +00:00
|
|
|
}
|
2005-04-24 01:47:23 +00:00
|
|
|
|
2019-03-24 12:13:16 +00:00
|
|
|
normalize_curl_result(&req->curl_result, req->http_code,
|
|
|
|
|
req->errorstr, sizeof(req->errorstr));
|
2016-07-11 20:51:30 +00:00
|
|
|
|
2005-11-18 19:03:04 +00:00
|
|
|
if (obj_req->state == ABORTED) {
|
2005-11-18 19:02:58 +00:00
|
|
|
ret = error("Request for %s aborted", hex);
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
} else if (req->curl_result != CURLE_OK &&
|
|
|
|
|
req->http_code != 416) {
|
|
|
|
|
if (missing_target(req))
|
2005-10-21 16:18:46 +00:00
|
|
|
ret = -1; /* Be silent, it is probably in a pack. */
|
|
|
|
|
else
|
|
|
|
|
ret = error("%s (curl_result = %d, http_code = %ld, sha1 = %s)",
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
req->errorstr, req->curl_result,
|
|
|
|
|
req->http_code, hex);
|
|
|
|
|
} else if (req->zret != Z_STREAM_END) {
|
2007-09-11 03:02:45 +00:00
|
|
|
walker->corrupt_object_found++;
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
ret = error("File %s (%s) corrupt", hex, req->url);
|
2019-01-07 08:34:40 +00:00
|
|
|
} else if (!oideq(&obj_req->oid, &req->real_oid)) {
|
2006-02-23 01:47:10 +00:00
|
|
|
ret = error("File %s has bad hash", hex);
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
} else if (req->rename < 0) {
|
2018-01-17 17:54:54 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
sha1-file: modernize loose object file functions
The loose object access code in sha1-file.c is some of the oldest in
Git, and could use some modernizing. It mostly uses "unsigned char *"
for object ids, which these days should be "struct object_id".
It also uses the term "sha1_file" in many functions, which is confusing.
The term "loose_objects" is much better. It clearly distinguishes
them from packed objects (which didn't even exist back when the name
"sha1_file" came into being). And it also distinguishes it from the
checksummed-file concept in csum-file.c (which until recently was
actually called "struct sha1file"!).
This patch converts the functions {open,close,map,stat}_sha1_file() into
open_loose_object(), etc, and switches their sha1 arguments for
object_id structs. Similarly, path functions like fill_sha1_path()
become fill_loose_path() and use object_ids.
The function sha1_loose_object_info() already says "loose", so we can
just drop the "sha1" (and teach it to use object_id).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-01-07 08:35:42 +00:00
|
|
|
loose_object_path(the_repository, &buf, &req->oid);
|
2018-01-17 17:54:54 +00:00
|
|
|
ret = error("unable to write sha1 filename %s", buf.buf);
|
|
|
|
|
strbuf_release(&buf);
|
2005-04-24 01:47:23 +00:00
|
|
|
}
|
2005-09-28 17:14:04 +00:00
|
|
|
|
http*: add helper methods for fetching objects (loose)
The code handling the fetching of loose objects in http-push.c and
http-walker.c have been refactored into new methods and a new struct
(object_http_request) in http.c. They are not meant to be invoked
elsewhere.
The new methods in http.c are
- new_http_object_request
- process_http_object_request
- finish_http_object_request
- abort_http_object_request
- release_http_object_request
and the new struct is http_object_request.
RANGER_HEADER_SIZE and no_pragma_header is no longer made available
outside of http.c, since after the above changes, there are no other
instances of usage outside of http.c.
Remove members of the transfer_request struct in http-push.c and
http-walker.c, including filename, real_sha1 and zret, as they are used
no longer used.
Move the methods append_remote_object_url() and get_remote_object_url()
from http-push.c to http.c. Additionally, get_remote_object_url() is no
longer defined only when USE_CURL_MULTI is defined, since
non-USE_CURL_MULTI code in http.c uses it (namely, in
new_http_object_request()).
Refactor code from http-push.c::start_fetch_loose() and
http-walker.c::start_object_fetch_request() that deals with the details
of coming up with the filename to store the retrieved object, resuming
a previously aborted request, and making a new curl request, into a new
function, new_http_object_request().
Refactor code from http-walker.c::process_object_request() into the
function, process_http_object_request().
Refactor code from http-push.c::finish_request() and
http-walker.c::finish_object_request() into a new function,
finish_http_object_request(). It returns the result of the
move_temp_to_file() invocation.
Add a function, release_http_object_request(), which cleans up object
request data. http-push.c and http-walker.c invoke this function
separately; http-push.c::release_request() and
http-walker.c::release_object_request() do not invoke this function.
Add a function, abort_http_object_request(), which unlink()s the object
file and invokes release_http_object_request(). Update
http-walker.c::abort_object_request() to use this.
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-06-06 08:44:02 +00:00
|
|
|
release_http_object_request(req);
|
2005-11-18 19:03:04 +00:00
|
|
|
release_object_request(obj_req);
|
2005-11-18 19:02:58 +00:00
|
|
|
return ret;
|
2005-04-24 01:47:23 +00:00
|
|
|
}
|
|
|
|
|
|
2019-02-19 00:05:12 +00:00
|
|
|
static int fetch(struct walker *walker, unsigned char *hash)
|
2005-09-15 03:26:08 +00:00
|
|
|
{
|
2007-09-11 03:02:45 +00:00
|
|
|
struct walker_data *data = walker->data;
|
|
|
|
|
struct alt_base *altbase = data->alt;
|
2005-10-11 06:22:01 +00:00
|
|
|
|
2019-02-19 00:05:12 +00:00
|
|
|
if (!fetch_object(walker, hash))
|
2005-10-11 06:22:01 +00:00
|
|
|
return 0;
|
2005-09-15 03:26:08 +00:00
|
|
|
while (altbase) {
|
2019-02-19 00:05:12 +00:00
|
|
|
if (!http_fetch_pack(walker, altbase, hash))
|
2005-09-15 03:26:08 +00:00
|
|
|
return 0;
|
2007-09-11 03:02:45 +00:00
|
|
|
fetch_alternates(walker, data->alt->base);
|
2005-09-15 03:26:08 +00:00
|
|
|
altbase = altbase->next;
|
|
|
|
|
}
|
2019-02-19 00:05:12 +00:00
|
|
|
return error("Unable to find %s under %s", hash_to_hex(hash),
|
2007-09-11 03:02:45 +00:00
|
|
|
data->alt->base);
|
2005-09-15 03:26:08 +00:00
|
|
|
}
|
|
|
|
|
|
Make walker.fetch_ref() take a struct ref.
This simplifies a few things, makes a few things slightly more
complicated, but, more importantly, allows that, when struct ref can
represent a symref, http_fetch_ref() can return one.
Incidentally makes the string that http_fetch_ref() gets include "refs/"
(if appropriate), because that's how the name field of struct ref works.
As far as I can tell, the usage in walker:interpret_target() wouldn't have
worked previously, if it ever would have been used, which it wouldn't
(since the fetch process uses the hash instead of the name of the ref
there).
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-04-26 19:53:09 +00:00
|
|
|
static int fetch_ref(struct walker *walker, struct ref *ref)
|
2005-06-06 20:38:26 +00:00
|
|
|
{
|
2007-09-11 03:02:45 +00:00
|
|
|
struct walker_data *data = walker->data;
|
Make walker.fetch_ref() take a struct ref.
This simplifies a few things, makes a few things slightly more
complicated, but, more importantly, allows that, when struct ref can
represent a symref, http_fetch_ref() can return one.
Incidentally makes the string that http_fetch_ref() gets include "refs/"
(if appropriate), because that's how the name field of struct ref works.
As far as I can tell, the usage in walker:interpret_target() wouldn't have
worked previously, if it ever would have been used, which it wouldn't
(since the fetch process uses the hash instead of the name of the ref
there).
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-04-26 19:53:09 +00:00
|
|
|
return http_fetch_ref(data->alt->base, ref);
|
2005-06-06 20:38:26 +00:00
|
|
|
}
|
|
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
static void cleanup(struct walker *walker)
|
|
|
|
|
{
|
2010-03-02 10:49:28 +00:00
|
|
|
struct walker_data *data = walker->data;
|
|
|
|
|
struct alt_base *alt, *alt_next;
|
|
|
|
|
|
|
|
|
|
if (data) {
|
|
|
|
|
alt = data->alt;
|
|
|
|
|
while (alt) {
|
|
|
|
|
alt_next = alt->next;
|
|
|
|
|
|
|
|
|
|
free(alt->base);
|
|
|
|
|
free(alt);
|
|
|
|
|
|
|
|
|
|
alt = alt_next;
|
|
|
|
|
}
|
|
|
|
|
free(data);
|
|
|
|
|
walker->data = NULL;
|
|
|
|
|
}
|
2007-09-11 03:02:45 +00:00
|
|
|
}
|
|
|
|
|
|
2010-03-02 10:49:29 +00:00
|
|
|
struct walker *get_http_walker(const char *url)
|
2005-04-24 01:47:23 +00:00
|
|
|
{
|
2007-03-28 09:47:35 +00:00
|
|
|
char *s;
|
2007-09-11 03:02:45 +00:00
|
|
|
struct walker_data *data = xmalloc(sizeof(struct walker_data));
|
|
|
|
|
struct walker *walker = xmalloc(sizeof(struct walker));
|
2005-04-24 01:47:23 +00:00
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
data->alt = xmalloc(sizeof(*data->alt));
|
2014-06-19 21:19:43 +00:00
|
|
|
data->alt->base = xstrdup(url);
|
2007-09-11 03:02:45 +00:00
|
|
|
for (s = data->alt->base + strlen(data->alt->base) - 1; *s == '/'; --s)
|
2007-03-28 09:47:35 +00:00
|
|
|
*s = 0;
|
2005-04-24 01:47:23 +00:00
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
data->alt->got_indices = 0;
|
|
|
|
|
data->alt->packs = NULL;
|
|
|
|
|
data->alt->next = NULL;
|
|
|
|
|
data->got_alternates = -1;
|
2007-09-11 03:02:34 +00:00
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
walker->corrupt_object_found = 0;
|
|
|
|
|
walker->fetch = fetch;
|
|
|
|
|
walker->fetch_ref = fetch_ref;
|
|
|
|
|
walker->prefetch = prefetch;
|
|
|
|
|
walker->cleanup = cleanup;
|
|
|
|
|
walker->data = data;
|
2005-04-24 01:47:23 +00:00
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
#ifdef USE_CURL_MULTI
|
|
|
|
|
add_fill_function(walker, (int (*)(void *)) fill_active_slot);
|
|
|
|
|
#endif
|
2006-07-27 21:56:22 +00:00
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
return walker;
|
2005-04-24 01:47:23 +00:00
|
|
|
}
|