2005-11-02 20:19:24 +01:00
# include "cache.h"
# include "commit.h"
# include "pack.h"
# include "fetch.h"
# include "tag.h"
# include "blob.h"
2005-11-18 20:02:58 +01:00
# include "http.h"
2006-03-08 01:13:20 +01:00
# include "refs.h"
2006-04-11 03:14:54 +02:00
# include "diff.h"
2006-03-08 01:13:20 +01:00
# include "revision.h"
2006-03-20 19:31:06 +01:00
# include "exec_cmd.h"
2005-11-18 20:02:58 +01:00
2005-11-06 22:07:45 +01:00
# include <expat.h>
2005-11-02 20:19:24 +01:00
static const char http_push_usage [ ] =
2006-03-11 05:18:33 +01:00
" git-http-push [--all] [--force] [--verbose] <remote> [<head>...] \n " ;
2005-11-02 20:19:24 +01:00
2005-11-07 19:23:11 +01:00
# ifndef XML_STATUS_OK
enum XML_Status {
XML_STATUS_OK = 1 ,
XML_STATUS_ERROR = 0
} ;
# define XML_STATUS_OK 1
# define XML_STATUS_ERROR 0
# endif
2006-03-11 05:18:18 +01:00
# define PREV_BUF_SIZE 4096
2005-11-02 20:19:24 +01:00
# define RANGE_HEADER_SIZE 30
2005-11-18 20:03:18 +01:00
/* DAV methods */
2005-11-02 20:19:24 +01:00
# define DAV_LOCK "LOCK"
# define DAV_MKCOL "MKCOL"
# define DAV_MOVE "MOVE"
# define DAV_PROPFIND "PROPFIND"
# define DAV_PUT "PUT"
# define DAV_UNLOCK "UNLOCK"
2006-03-20 19:31:06 +01:00
# define DAV_DELETE "DELETE"
2005-11-18 20:03:18 +01:00
/* DAV lock flags */
# define DAV_PROP_LOCKWR (1u << 0)
# define DAV_PROP_LOCKEX (1u << 1)
# define DAV_LOCK_OK (1u << 2)
/* DAV XML properties */
# define DAV_CTX_LOCKENTRY ".multistatus.response.propstat.prop.supportedlock.lockentry"
# define DAV_CTX_LOCKTYPE_WRITE ".multistatus.response.propstat.prop.supportedlock.lockentry.locktype.write"
# define DAV_CTX_LOCKTYPE_EXCLUSIVE ".multistatus.response.propstat.prop.supportedlock.lockentry.lockscope.exclusive"
# define DAV_ACTIVELOCK_OWNER ".prop.lockdiscovery.activelock.owner.href"
# define DAV_ACTIVELOCK_TIMEOUT ".prop.lockdiscovery.activelock.timeout"
# define DAV_ACTIVELOCK_TOKEN ".prop.lockdiscovery.activelock.locktoken.href"
2006-03-08 01:13:20 +01:00
# define DAV_PROPFIND_RESP ".multistatus.response"
# define DAV_PROPFIND_NAME ".multistatus.response.href"
# define DAV_PROPFIND_COLLECTION ".multistatus.response.propstat.prop.resourcetype.collection"
2005-11-18 20:03:18 +01:00
/* DAV request body templates */
2006-03-08 01:13:20 +01:00
# define PROPFIND_SUPPORTEDLOCK_REQUEST "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<D:propfind xmlns:D=\"DAV:\">\n<D:prop xmlns:R=\"%s\">\n<D:supportedlock / >\n< / D:prop>\n< / D:propfind>"
# define PROPFIND_ALL_REQUEST "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<D:propfind xmlns:D=\"DAV:\">\n<D:allprop / >\n< / D:propfind>"
2005-11-02 20:19:24 +01:00
# define LOCK_REQUEST "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<D:lockinfo xmlns:D=\"DAV:\">\n<D:lockscope><D:exclusive / >< / D:lockscope>\n<D:locktype><D:write / >< / D:locktype>\n<D:owner>\n<D:href>mailto:%s< / D:href>\n< / D:owner>\n< / D:lockinfo>"
2005-11-04 23:22:35 +01:00
# define LOCK_TIME 600
# define LOCK_REFRESH 30
2006-04-17 03:12:49 +02:00
/* bits #0-15 in revision.h */
2006-03-08 01:13:20 +01:00
2006-04-17 03:12:49 +02:00
# define LOCAL (1u<<16)
# define REMOTE (1u<<17)
# define FETCHING (1u<<18)
# define PUSHING (1u<<19)
2006-03-08 01:13:20 +01:00
2006-03-20 19:31:06 +01:00
/* We allow "recursive" symbolic refs. Only within reason, though */
# define MAXDEPTH 5
2005-11-02 20:19:24 +01:00
static int pushing = 0 ;
static int aborted = 0 ;
2006-03-20 20:50:51 +01:00
static signed char remote_dir_exists [ 256 ] ;
2005-11-02 20:19:24 +01:00
static struct curl_slist * no_pragma_header ;
static struct curl_slist * default_headers ;
static int push_verbosely = 0 ;
static int push_all = 0 ;
static int force_all = 0 ;
2006-03-08 01:13:20 +01:00
static struct object_list * objects = NULL ;
2005-11-02 20:19:24 +01:00
struct repo
{
char * url ;
2006-03-08 01:13:20 +01:00
int path_len ;
2006-03-11 05:18:18 +01:00
int has_info_refs ;
int can_update_info_refs ;
int has_info_packs ;
2005-11-02 20:19:24 +01:00
struct packed_git * packs ;
2006-03-11 05:18:12 +01:00
struct remote_lock * locks ;
2005-11-02 20:19:24 +01:00
} ;
static struct repo * remote = NULL ;
enum transfer_state {
2006-03-11 05:18:18 +01:00
NEED_FETCH ,
RUN_FETCH_LOOSE ,
RUN_FETCH_PACKED ,
2005-11-02 20:19:24 +01:00
NEED_PUSH ,
RUN_MKCOL ,
RUN_PUT ,
RUN_MOVE ,
ABORTED ,
COMPLETE ,
} ;
struct transfer_request
{
2006-03-08 01:13:20 +01:00
struct object * obj ;
2005-11-02 20:19:24 +01:00
char * url ;
char * dest ;
2006-03-08 01:13:20 +01:00
struct remote_lock * lock ;
2005-11-02 20:19:24 +01:00
struct curl_slist * headers ;
struct buffer buffer ;
char filename [ PATH_MAX ] ;
char tmpfile [ PATH_MAX ] ;
2006-03-11 05:18:18 +01:00
int local_fileno ;
FILE * local_stream ;
2005-11-02 20:19:24 +01:00
enum transfer_state state ;
CURLcode curl_result ;
char errorstr [ CURL_ERROR_SIZE ] ;
long http_code ;
unsigned char real_sha1 [ 20 ] ;
SHA_CTX c ;
z_stream stream ;
int zret ;
int rename ;
2006-03-11 05:18:18 +01:00
void * userData ;
2005-11-02 20:19:24 +01:00
struct active_request_slot * slot ;
struct transfer_request * next ;
} ;
static struct transfer_request * request_queue_head = NULL ;
2005-11-18 20:03:18 +01:00
struct xml_ctx
{
char * name ;
int len ;
char * cdata ;
void ( * userFunc ) ( struct xml_ctx * ctx , int tag_closed ) ;
void * userData ;
} ;
2006-03-08 01:13:20 +01:00
struct remote_lock
2005-11-04 23:22:31 +01:00
{
2005-11-04 23:22:35 +01:00
char * url ;
2005-11-04 23:22:31 +01:00
char * owner ;
2005-11-04 23:22:35 +01:00
char * token ;
2005-11-04 23:22:31 +01:00
time_t start_time ;
long timeout ;
2005-11-04 23:22:35 +01:00
int refreshing ;
2006-03-08 01:13:20 +01:00
struct remote_lock * next ;
} ;
2006-03-11 05:18:08 +01:00
/* Flags that control remote_ls processing */
# define PROCESS_FILES (1u << 0)
# define PROCESS_DIRS (1u << 1)
# define RECURSIVE (1u << 2)
/* Flags that remote_ls passes to callback functions */
# define IS_DIR (1u << 0)
struct remote_ls_ctx
2006-03-08 01:13:20 +01:00
{
2006-03-11 05:18:08 +01:00
char * path ;
void ( * userFunc ) ( struct remote_ls_ctx * ls ) ;
void * userData ;
int flags ;
char * dentry_name ;
int dentry_flags ;
struct remote_ls_ctx * parent ;
2005-11-04 23:22:31 +01:00
} ;
2005-11-18 20:02:58 +01:00
static void finish_request ( struct transfer_request * request ) ;
2006-03-11 05:18:18 +01:00
static void release_request ( struct transfer_request * request ) ;
2005-11-02 20:19:24 +01:00
2005-11-18 20:02:58 +01:00
static void process_response ( void * callback_data )
2005-11-02 20:19:24 +01:00
{
2005-11-18 20:02:58 +01:00
struct transfer_request * request =
( struct transfer_request * ) callback_data ;
2005-11-02 20:19:24 +01:00
2005-11-18 20:02:58 +01:00
finish_request ( request ) ;
2005-11-02 20:19:24 +01:00
}
2006-06-06 23:26:57 +02:00
# ifdef USE_CURL_MULTI
2006-03-11 05:18:18 +01:00
static size_t fwrite_sha1_file ( void * ptr , size_t eltsize , size_t nmemb ,
void * data )
{
unsigned char expn [ 4096 ] ;
size_t size = eltsize * nmemb ;
int posn = 0 ;
struct transfer_request * request = ( struct transfer_request * ) data ;
do {
ssize_t retval = write ( request - > local_fileno ,
2006-06-18 17:18:09 +02:00
( char * ) ptr + posn , size - posn ) ;
2006-03-11 05:18:18 +01:00
if ( retval < 0 )
return posn ;
posn + = retval ;
} while ( posn < size ) ;
request - > stream . avail_in = size ;
request - > stream . next_in = ptr ;
do {
request - > stream . next_out = expn ;
request - > stream . avail_out = sizeof ( expn ) ;
request - > zret = inflate ( & request - > stream , Z_SYNC_FLUSH ) ;
SHA1_Update ( & request - > c , expn ,
sizeof ( expn ) - request - > stream . avail_out ) ;
} while ( request - > stream . avail_in & & request - > zret = = Z_OK ) ;
data_received + + ;
return size ;
}
static void start_fetch_loose ( struct transfer_request * request )
{
char * hex = sha1_to_hex ( request - > obj - > sha1 ) ;
char * filename ;
char prevfile [ PATH_MAX ] ;
char * url ;
char * posn ;
int prevlocal ;
unsigned char prev_buf [ PREV_BUF_SIZE ] ;
ssize_t prev_read = 0 ;
long prev_posn = 0 ;
char range [ RANGE_HEADER_SIZE ] ;
struct curl_slist * range_header = NULL ;
struct active_request_slot * slot ;
filename = sha1_file_name ( request - > obj - > sha1 ) ;
snprintf ( request - > filename , sizeof ( request - > filename ) , " %s " , filename ) ;
snprintf ( request - > tmpfile , sizeof ( request - > tmpfile ) ,
" %s.temp " , filename ) ;
snprintf ( prevfile , sizeof ( prevfile ) , " %s.prev " , request - > filename ) ;
unlink ( prevfile ) ;
rename ( request - > tmpfile , prevfile ) ;
unlink ( request - > tmpfile ) ;
if ( request - > local_fileno ! = - 1 )
error ( " fd leakage in start: %d " , request - > local_fileno ) ;
request - > local_fileno = open ( request - > tmpfile ,
O_WRONLY | O_CREAT | O_EXCL , 0666 ) ;
/* This could have failed due to the "lazy directory creation";
* try to mkdir the last path component .
*/
if ( request - > local_fileno < 0 & & errno = = ENOENT ) {
char * dir = strrchr ( request - > tmpfile , ' / ' ) ;
if ( dir ) {
* dir = 0 ;
mkdir ( request - > tmpfile , 0777 ) ;
* dir = ' / ' ;
}
request - > local_fileno = open ( request - > tmpfile ,
O_WRONLY | O_CREAT | O_EXCL , 0666 ) ;
}
if ( request - > local_fileno < 0 ) {
request - > state = ABORTED ;
error ( " Couldn't create temporary file %s for %s: %s " ,
request - > tmpfile , request - > filename , strerror ( errno ) ) ;
return ;
}
memset ( & request - > stream , 0 , sizeof ( request - > stream ) ) ;
inflateInit ( & request - > stream ) ;
SHA1_Init ( & request - > c ) ;
url = xmalloc ( strlen ( remote - > url ) + 50 ) ;
request - > url = xmalloc ( strlen ( remote - > url ) + 50 ) ;
strcpy ( url , remote - > url ) ;
posn = url + strlen ( remote - > url ) ;
strcpy ( posn , " objects/ " ) ;
posn + = 8 ;
memcpy ( posn , hex , 2 ) ;
posn + = 2 ;
* ( posn + + ) = ' / ' ;
strcpy ( posn , hex + 2 ) ;
strcpy ( request - > url , url ) ;
/* If a previous temp file is present, process what was already
fetched . */
prevlocal = open ( prevfile , O_RDONLY ) ;
if ( prevlocal ! = - 1 ) {
do {
prev_read = read ( prevlocal , prev_buf , PREV_BUF_SIZE ) ;
if ( prev_read > 0 ) {
if ( fwrite_sha1_file ( prev_buf ,
1 ,
prev_read ,
request ) = = prev_read ) {
prev_posn + = prev_read ;
} else {
prev_read = - 1 ;
}
}
} while ( prev_read > 0 ) ;
close ( prevlocal ) ;
}
unlink ( prevfile ) ;
/* Reset inflate/SHA1 if there was an error reading the previous temp
file ; also rewind to the beginning of the local file . */
if ( prev_read = = - 1 ) {
memset ( & request - > stream , 0 , sizeof ( request - > stream ) ) ;
inflateInit ( & request - > stream ) ;
SHA1_Init ( & request - > c ) ;
if ( prev_posn > 0 ) {
prev_posn = 0 ;
lseek ( request - > local_fileno , SEEK_SET , 0 ) ;
ftruncate ( request - > local_fileno , 0 ) ;
}
}
slot = get_active_slot ( ) ;
slot - > callback_func = process_response ;
slot - > callback_data = request ;
request - > slot = slot ;
curl_easy_setopt ( slot - > curl , CURLOPT_FILE , request ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_WRITEFUNCTION , fwrite_sha1_file ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_ERRORBUFFER , request - > errorstr ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_URL , url ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_HTTPHEADER , no_pragma_header ) ;
/* If we have successfully processed data from a previous fetch
attempt , only fetch the data we don ' t already have . */
if ( prev_posn > 0 ) {
if ( push_verbosely )
fprintf ( stderr ,
" Resuming fetch of object %s at byte %ld \n " ,
hex , prev_posn ) ;
sprintf ( range , " Range: bytes=%ld- " , prev_posn ) ;
range_header = curl_slist_append ( range_header , range ) ;
curl_easy_setopt ( slot - > curl ,
CURLOPT_HTTPHEADER , range_header ) ;
}
/* Try to get the request started, abort the request on error */
request - > state = RUN_FETCH_LOOSE ;
if ( ! start_active_slot ( slot ) ) {
fprintf ( stderr , " Unable to start GET request \n " ) ;
remote - > can_update_info_refs = 0 ;
release_request ( request ) ;
}
}
2006-06-06 23:26:57 +02:00
static void start_mkcol ( struct transfer_request * request )
{
char * hex = sha1_to_hex ( request - > obj - > sha1 ) ;
struct active_request_slot * slot ;
char * posn ;
request - > url = xmalloc ( strlen ( remote - > url ) + 13 ) ;
strcpy ( request - > url , remote - > url ) ;
posn = request - > url + strlen ( remote - > url ) ;
strcpy ( posn , " objects/ " ) ;
posn + = 8 ;
memcpy ( posn , hex , 2 ) ;
posn + = 2 ;
strcpy ( posn , " / " ) ;
slot = get_active_slot ( ) ;
slot - > callback_func = process_response ;
slot - > callback_data = request ;
curl_easy_setopt ( slot - > curl , CURLOPT_HTTPGET , 1 ) ; /* undo PUT setup */
curl_easy_setopt ( slot - > curl , CURLOPT_URL , request - > url ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_ERRORBUFFER , request - > errorstr ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_CUSTOMREQUEST , DAV_MKCOL ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_WRITEFUNCTION , fwrite_null ) ;
if ( start_active_slot ( slot ) ) {
request - > slot = slot ;
request - > state = RUN_MKCOL ;
} else {
request - > state = ABORTED ;
free ( request - > url ) ;
request - > url = NULL ;
}
}
# endif
2006-03-11 05:18:18 +01:00
static void start_fetch_packed ( struct transfer_request * request )
{
char * url ;
struct packed_git * target ;
FILE * packfile ;
char * filename ;
long prev_posn = 0 ;
char range [ RANGE_HEADER_SIZE ] ;
struct curl_slist * range_header = NULL ;
struct transfer_request * check_request = request_queue_head ;
struct active_request_slot * slot ;
target = find_sha1_pack ( request - > obj - > sha1 , remote - > packs ) ;
if ( ! target ) {
fprintf ( stderr , " Unable to fetch %s, will not be able to update server info refs \n " , sha1_to_hex ( request - > obj - > sha1 ) ) ;
remote - > can_update_info_refs = 0 ;
release_request ( request ) ;
return ;
}
fprintf ( stderr , " Fetching pack %s \n " , sha1_to_hex ( target - > sha1 ) ) ;
fprintf ( stderr , " which contains %s \n " , sha1_to_hex ( request - > obj - > sha1 ) ) ;
filename = sha1_pack_name ( target - > sha1 ) ;
snprintf ( request - > filename , sizeof ( request - > filename ) , " %s " , filename ) ;
snprintf ( request - > tmpfile , sizeof ( request - > tmpfile ) ,
" %s.temp " , filename ) ;
url = xmalloc ( strlen ( remote - > url ) + 64 ) ;
sprintf ( url , " %sobjects/pack/pack-%s.pack " ,
remote - > url , sha1_to_hex ( target - > sha1 ) ) ;
/* Make sure there isn't another open request for this pack */
while ( check_request ) {
if ( check_request - > state = = RUN_FETCH_PACKED & &
! strcmp ( check_request - > url , url ) ) {
free ( url ) ;
release_request ( request ) ;
return ;
}
check_request = check_request - > next ;
}
packfile = fopen ( request - > tmpfile , " a " ) ;
if ( ! packfile ) {
fprintf ( stderr , " Unable to open local file %s for pack " ,
filename ) ;
remote - > can_update_info_refs = 0 ;
free ( url ) ;
return ;
}
slot = get_active_slot ( ) ;
slot - > callback_func = process_response ;
slot - > callback_data = request ;
request - > slot = slot ;
request - > local_stream = packfile ;
request - > userData = target ;
request - > url = url ;
curl_easy_setopt ( slot - > curl , CURLOPT_FILE , packfile ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_WRITEFUNCTION , fwrite ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_URL , url ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_HTTPHEADER , no_pragma_header ) ;
slot - > local = packfile ;
/* If there is data present from a previous transfer attempt,
resume where it left off */
prev_posn = ftell ( packfile ) ;
if ( prev_posn > 0 ) {
if ( push_verbosely )
fprintf ( stderr ,
" Resuming fetch of pack %s at byte %ld \n " ,
sha1_to_hex ( target - > sha1 ) , prev_posn ) ;
sprintf ( range , " Range: bytes=%ld- " , prev_posn ) ;
range_header = curl_slist_append ( range_header , range ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_HTTPHEADER , range_header ) ;
}
/* Try to get the request started, abort the request on error */
request - > state = RUN_FETCH_PACKED ;
if ( ! start_active_slot ( slot ) ) {
fprintf ( stderr , " Unable to start GET request \n " ) ;
remote - > can_update_info_refs = 0 ;
release_request ( request ) ;
}
}
2005-11-02 20:19:24 +01:00
static void start_put ( struct transfer_request * request )
{
2006-03-08 01:13:20 +01:00
char * hex = sha1_to_hex ( request - > obj - > sha1 ) ;
2005-11-02 20:19:24 +01:00
struct active_request_slot * slot ;
char * posn ;
char type [ 20 ] ;
char hdr [ 50 ] ;
void * unpacked ;
unsigned long len ;
int hdrlen ;
ssize_t size ;
z_stream stream ;
2006-03-08 01:13:20 +01:00
unpacked = read_sha1_file ( request - > obj - > sha1 , type , & len ) ;
2005-11-02 20:19:24 +01:00
hdrlen = sprintf ( hdr , " %s %lu " , type , len ) + 1 ;
/* Set it up */
memset ( & stream , 0 , sizeof ( stream ) ) ;
2006-07-03 22:11:47 +02:00
deflateInit ( & stream , zlib_compression_level ) ;
2005-11-02 20:19:24 +01:00
size = deflateBound ( & stream , len + hdrlen ) ;
request - > buffer . buffer = xmalloc ( size ) ;
/* Compress it */
stream . next_out = request - > buffer . buffer ;
stream . avail_out = size ;
/* First header.. */
stream . next_in = ( void * ) hdr ;
stream . avail_in = hdrlen ;
while ( deflate ( & stream , 0 ) = = Z_OK )
/* nothing */ ;
/* Then the data itself.. */
stream . next_in = unpacked ;
stream . avail_in = len ;
while ( deflate ( & stream , Z_FINISH ) = = Z_OK )
/* nothing */ ;
deflateEnd ( & stream ) ;
free ( unpacked ) ;
request - > buffer . size = stream . total_out ;
request - > buffer . posn = 0 ;
request - > url = xmalloc ( strlen ( remote - > url ) +
2005-11-04 23:22:31 +01:00
strlen ( request - > lock - > token ) + 51 ) ;
2005-11-02 20:19:24 +01:00
strcpy ( request - > url , remote - > url ) ;
posn = request - > url + strlen ( remote - > url ) ;
strcpy ( posn , " objects/ " ) ;
posn + = 8 ;
memcpy ( posn , hex , 2 ) ;
posn + = 2 ;
* ( posn + + ) = ' / ' ;
strcpy ( posn , hex + 2 ) ;
request - > dest = xmalloc ( strlen ( request - > url ) + 14 ) ;
sprintf ( request - > dest , " Destination: %s " , request - > url ) ;
posn + = 38 ;
* ( posn + + ) = ' . ' ;
2005-11-04 23:22:31 +01:00
strcpy ( posn , request - > lock - > token ) ;
2005-11-02 20:19:24 +01:00
slot = get_active_slot ( ) ;
2005-11-18 20:02:58 +01:00
slot - > callback_func = process_response ;
slot - > callback_data = request ;
2005-11-02 20:19:24 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_INFILE , & request - > buffer ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_INFILESIZE , request - > buffer . size ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_READFUNCTION , fread_buffer ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_WRITEFUNCTION , fwrite_null ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_CUSTOMREQUEST , DAV_PUT ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_UPLOAD , 1 ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_PUT , 1 ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_NOBODY , 0 ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_URL , request - > url ) ;
if ( start_active_slot ( slot ) ) {
request - > slot = slot ;
request - > state = RUN_PUT ;
} else {
request - > state = ABORTED ;
free ( request - > url ) ;
2005-11-18 20:03:25 +01:00
request - > url = NULL ;
2005-11-02 20:19:24 +01:00
}
}
static void start_move ( struct transfer_request * request )
{
struct active_request_slot * slot ;
struct curl_slist * dav_headers = NULL ;
slot = get_active_slot ( ) ;
2005-11-18 20:02:58 +01:00
slot - > callback_func = process_response ;
slot - > callback_data = request ;
2005-11-02 20:19:24 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_HTTPGET , 1 ) ; /* undo PUT setup */
curl_easy_setopt ( slot - > curl , CURLOPT_CUSTOMREQUEST , DAV_MOVE ) ;
dav_headers = curl_slist_append ( dav_headers , request - > dest ) ;
dav_headers = curl_slist_append ( dav_headers , " Overwrite: T " ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_HTTPHEADER , dav_headers ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_WRITEFUNCTION , fwrite_null ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_URL , request - > url ) ;
if ( start_active_slot ( slot ) ) {
request - > slot = slot ;
request - > state = RUN_MOVE ;
} else {
request - > state = ABORTED ;
free ( request - > url ) ;
2005-11-18 20:03:25 +01:00
request - > url = NULL ;
2005-11-02 20:19:24 +01:00
}
}
2006-03-11 05:18:12 +01:00
static int refresh_lock ( struct remote_lock * lock )
2005-11-04 23:22:35 +01:00
{
struct active_request_slot * slot ;
2006-03-11 05:18:01 +01:00
struct slot_results results ;
2005-11-04 23:22:35 +01:00
char * if_header ;
char timeout_header [ 25 ] ;
struct curl_slist * dav_headers = NULL ;
2006-03-11 05:18:12 +01:00
int rc = 0 ;
2005-11-04 23:22:35 +01:00
2006-03-11 05:18:12 +01:00
lock - > refreshing = 1 ;
2005-11-04 23:22:35 +01:00
2006-03-11 05:18:12 +01:00
if_header = xmalloc ( strlen ( lock - > token ) + 25 ) ;
sprintf ( if_header , " If: (<opaquelocktoken:%s>) " , lock - > token ) ;
sprintf ( timeout_header , " Timeout: Second-%ld " , lock - > timeout ) ;
dav_headers = curl_slist_append ( dav_headers , if_header ) ;
dav_headers = curl_slist_append ( dav_headers , timeout_header ) ;
2005-11-04 23:22:35 +01:00
2006-03-11 05:18:12 +01:00
slot = get_active_slot ( ) ;
slot - > results = & results ;
curl_easy_setopt ( slot - > curl , CURLOPT_HTTPGET , 1 ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_WRITEFUNCTION , fwrite_null ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_URL , lock - > url ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_CUSTOMREQUEST , DAV_LOCK ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_HTTPHEADER , dav_headers ) ;
2005-11-04 23:22:35 +01:00
2006-03-11 05:18:12 +01:00
if ( start_active_slot ( slot ) ) {
run_active_slot ( slot ) ;
if ( results . curl_result ! = CURLE_OK ) {
fprintf ( stderr , " LOCK HTTP error %ld \n " ,
results . http_code ) ;
} else {
lock - > start_time = time ( NULL ) ;
rc = 1 ;
}
}
2006-03-08 01:13:20 +01:00
2006-03-11 05:18:12 +01:00
lock - > refreshing = 0 ;
curl_slist_free_all ( dav_headers ) ;
free ( if_header ) ;
2006-03-08 01:13:20 +01:00
2006-03-11 05:18:12 +01:00
return rc ;
}
2006-04-02 13:13:10 +02:00
static void check_locks ( void )
2006-03-11 05:18:12 +01:00
{
struct remote_lock * lock = remote - > locks ;
time_t current_time = time ( NULL ) ;
int time_remaining ;
while ( lock ) {
time_remaining = lock - > start_time + lock - > timeout -
current_time ;
if ( ! lock - > refreshing & & time_remaining < LOCK_REFRESH ) {
if ( ! refresh_lock ( lock ) ) {
fprintf ( stderr ,
" Unable to refresh lock for %s \n " ,
lock - > url ) ;
aborted = 1 ;
return ;
2006-03-08 01:13:20 +01:00
}
2005-11-04 23:22:35 +01:00
}
2006-03-11 05:18:12 +01:00
lock = lock - > next ;
2005-11-04 23:22:35 +01:00
}
2006-03-08 01:13:20 +01:00
}
2005-11-04 23:22:35 +01:00
2006-03-08 01:13:20 +01:00
static void release_request ( struct transfer_request * request )
{
struct transfer_request * entry = request_queue_head ;
if ( request = = request_queue_head ) {
request_queue_head = request - > next ;
} else {
while ( entry - > next ! = NULL & & entry - > next ! = request )
entry = entry - > next ;
if ( entry - > next = = request )
entry - > next = entry - > next - > next ;
}
2006-03-11 05:18:18 +01:00
if ( request - > local_fileno ! = - 1 )
close ( request - > local_fileno ) ;
if ( request - > local_stream )
fclose ( request - > local_stream ) ;
2006-03-08 01:13:20 +01:00
if ( request - > url ! = NULL )
free ( request - > url ) ;
free ( request ) ;
2005-11-04 23:22:35 +01:00
}
2005-11-02 20:19:24 +01:00
static void finish_request ( struct transfer_request * request )
{
2006-03-11 05:18:18 +01:00
struct stat st ;
struct packed_git * target ;
struct packed_git * * lst ;
request - > curl_result = request - > slot - > curl_result ;
2005-11-02 20:19:24 +01:00
request - > http_code = request - > slot - > http_code ;
request - > slot = NULL ;
2005-11-04 23:22:35 +01:00
2006-03-08 01:13:20 +01:00
/* Keep locks active */
2006-03-11 05:18:12 +01:00
check_locks ( ) ;
2005-11-04 23:22:35 +01:00
2005-11-02 20:19:24 +01:00
if ( request - > headers ! = NULL )
curl_slist_free_all ( request - > headers ) ;
2005-11-18 20:03:25 +01:00
/* URL is reused for MOVE after PUT */
if ( request - > state ! = RUN_PUT ) {
free ( request - > url ) ;
request - > url = NULL ;
2006-03-08 01:13:20 +01:00
}
2005-11-18 20:03:25 +01:00
2006-03-08 01:13:20 +01:00
if ( request - > state = = RUN_MKCOL ) {
2005-11-02 20:19:24 +01:00
if ( request - > curl_result = = CURLE_OK | |
request - > http_code = = 405 ) {
2006-03-08 01:13:20 +01:00
remote_dir_exists [ request - > obj - > sha1 [ 0 ] ] = 1 ;
2005-11-02 20:19:24 +01:00
start_put ( request ) ;
} else {
fprintf ( stderr , " MKCOL %s failed, aborting (%d/%ld) \n " ,
2006-03-08 01:13:20 +01:00
sha1_to_hex ( request - > obj - > sha1 ) ,
2005-11-02 20:19:24 +01:00
request - > curl_result , request - > http_code ) ;
request - > state = ABORTED ;
aborted = 1 ;
}
} else if ( request - > state = = RUN_PUT ) {
if ( request - > curl_result = = CURLE_OK ) {
start_move ( request ) ;
} else {
fprintf ( stderr , " PUT %s failed, aborting (%d/%ld) \n " ,
2006-03-08 01:13:20 +01:00
sha1_to_hex ( request - > obj - > sha1 ) ,
2005-11-02 20:19:24 +01:00
request - > curl_result , request - > http_code ) ;
request - > state = ABORTED ;
aborted = 1 ;
}
} else if ( request - > state = = RUN_MOVE ) {
if ( request - > curl_result = = CURLE_OK ) {
2006-03-11 05:18:33 +01:00
if ( push_verbosely )
fprintf ( stderr , " sent %s \n " ,
sha1_to_hex ( request - > obj - > sha1 ) ) ;
2006-03-08 01:13:20 +01:00
request - > obj - > flags | = REMOTE ;
release_request ( request ) ;
2005-11-02 20:19:24 +01:00
} else {
fprintf ( stderr , " MOVE %s failed, aborting (%d/%ld) \n " ,
2006-03-08 01:13:20 +01:00
sha1_to_hex ( request - > obj - > sha1 ) ,
2005-11-02 20:19:24 +01:00
request - > curl_result , request - > http_code ) ;
request - > state = ABORTED ;
aborted = 1 ;
}
2006-03-11 05:18:18 +01:00
} else if ( request - > state = = RUN_FETCH_LOOSE ) {
fchmod ( request - > local_fileno , 0444 ) ;
close ( request - > local_fileno ) ; request - > local_fileno = - 1 ;
if ( request - > curl_result ! = CURLE_OK & &
request - > http_code ! = 416 ) {
if ( stat ( request - > tmpfile , & st ) = = 0 ) {
if ( st . st_size = = 0 )
unlink ( request - > tmpfile ) ;
}
} else {
if ( request - > http_code = = 416 )
fprintf ( stderr , " Warning: requested range invalid; we may already have all the data. \n " ) ;
inflateEnd ( & request - > stream ) ;
SHA1_Final ( request - > real_sha1 , & request - > c ) ;
if ( request - > zret ! = Z_STREAM_END ) {
unlink ( request - > tmpfile ) ;
} else if ( memcmp ( request - > obj - > sha1 , request - > real_sha1 , 20 ) ) {
unlink ( request - > tmpfile ) ;
} else {
request - > rename =
move_temp_to_file (
request - > tmpfile ,
request - > filename ) ;
if ( request - > rename = = 0 ) {
request - > obj - > flags | = ( LOCAL | REMOTE ) ;
}
}
}
/* Try fetching packed if necessary */
if ( request - > obj - > flags & LOCAL )
release_request ( request ) ;
else
start_fetch_packed ( request ) ;
} else if ( request - > state = = RUN_FETCH_PACKED ) {
if ( request - > curl_result ! = CURLE_OK ) {
fprintf ( stderr , " Unable to get pack file %s \n %s " ,
request - > url , curl_errorstr ) ;
remote - > can_update_info_refs = 0 ;
} else {
fclose ( request - > local_stream ) ;
request - > local_stream = NULL ;
if ( ! move_temp_to_file ( request - > tmpfile ,
request - > filename ) ) {
target = ( struct packed_git * ) request - > userData ;
lst = & remote - > packs ;
while ( * lst ! = target )
lst = & ( ( * lst ) - > next ) ;
* lst = ( * lst ) - > next ;
if ( ! verify_pack ( target , 0 ) )
install_packed_git ( target ) ;
else
remote - > can_update_info_refs = 0 ;
}
}
release_request ( request ) ;
2005-11-02 20:19:24 +01:00
}
}
2006-06-06 18:41:32 +02:00
# ifdef USE_CURL_MULTI
2005-11-18 20:02:58 +01:00
void fill_active_slots ( void )
2005-11-02 20:19:24 +01:00
{
struct transfer_request * request = request_queue_head ;
2006-03-11 05:18:18 +01:00
struct transfer_request * next ;
2005-11-02 20:19:24 +01:00
struct active_request_slot * slot = active_queue_head ;
int num_transfers ;
if ( aborted )
return ;
while ( active_requests < max_requests & & request ! = NULL ) {
2006-03-11 05:18:18 +01:00
next = request - > next ;
if ( request - > state = = NEED_FETCH ) {
start_fetch_loose ( request ) ;
} else if ( pushing & & request - > state = = NEED_PUSH ) {
2006-03-08 01:13:20 +01:00
if ( remote_dir_exists [ request - > obj - > sha1 [ 0 ] ] = = 1 ) {
2005-11-07 20:39:37 +01:00
start_put ( request ) ;
2006-03-08 01:13:20 +01:00
} else {
2005-11-07 20:39:37 +01:00
start_mkcol ( request ) ;
2006-03-08 01:13:20 +01:00
}
2005-11-02 20:19:24 +01:00
curl_multi_perform ( curlm , & num_transfers ) ;
}
2006-03-11 05:18:18 +01:00
request = next ;
2005-11-02 20:19:24 +01:00
}
while ( slot ! = NULL ) {
if ( ! slot - > in_use & & slot - > curl ! = NULL ) {
curl_easy_cleanup ( slot - > curl ) ;
slot - > curl = NULL ;
}
slot = slot - > next ;
2006-03-08 01:13:20 +01:00
}
2005-11-02 20:19:24 +01:00
}
2006-06-06 18:41:32 +02:00
# endif
2005-11-02 20:19:24 +01:00
2006-03-08 01:13:20 +01:00
static void get_remote_object_list ( unsigned char parent ) ;
2006-03-11 05:18:18 +01:00
static void add_fetch_request ( struct object * obj )
{
struct transfer_request * request ;
check_locks ( ) ;
/*
* Don ' t fetch the object if it ' s known to exist locally
* or is already in the request queue
*/
if ( remote_dir_exists [ obj - > sha1 [ 0 ] ] = = - 1 )
get_remote_object_list ( obj - > sha1 [ 0 ] ) ;
if ( obj - > flags & ( LOCAL | FETCHING ) )
return ;
obj - > flags | = FETCHING ;
request = xmalloc ( sizeof ( * request ) ) ;
request - > obj = obj ;
request - > url = NULL ;
request - > lock = NULL ;
request - > headers = NULL ;
request - > local_fileno = - 1 ;
request - > local_stream = NULL ;
request - > state = NEED_FETCH ;
request - > next = request_queue_head ;
request_queue_head = request ;
2006-06-06 18:41:32 +02:00
# ifdef USE_CURL_MULTI
2006-03-11 05:18:18 +01:00
fill_active_slots ( ) ;
step_active_slots ( ) ;
2006-06-06 18:41:32 +02:00
# endif
2006-03-11 05:18:18 +01:00
}
2006-03-11 05:18:33 +01:00
static int add_send_request ( struct object * obj , struct remote_lock * lock )
2005-11-02 20:19:24 +01:00
{
struct transfer_request * request = request_queue_head ;
struct packed_git * target ;
2006-03-11 05:18:12 +01:00
/* Keep locks active */
check_locks ( ) ;
2006-03-08 01:13:20 +01:00
/*
* Don ' t push the object if it ' s known to exist on the remote
* or is already in the request queue
*/
if ( remote_dir_exists [ obj - > sha1 [ 0 ] ] = = - 1 )
get_remote_object_list ( obj - > sha1 [ 0 ] ) ;
if ( obj - > flags & ( REMOTE | PUSHING ) )
2006-03-11 05:18:33 +01:00
return 0 ;
2006-03-08 01:13:20 +01:00
target = find_sha1_pack ( obj - > sha1 , remote - > packs ) ;
if ( target ) {
obj - > flags | = REMOTE ;
2006-03-11 05:18:33 +01:00
return 0 ;
2006-03-08 01:13:20 +01:00
}
2005-11-02 20:19:24 +01:00
2006-03-08 01:13:20 +01:00
obj - > flags | = PUSHING ;
2005-11-02 20:19:24 +01:00
request = xmalloc ( sizeof ( * request ) ) ;
2006-03-08 01:13:20 +01:00
request - > obj = obj ;
2005-11-02 20:19:24 +01:00
request - > url = NULL ;
2005-11-04 23:22:31 +01:00
request - > lock = lock ;
2005-11-02 20:19:24 +01:00
request - > headers = NULL ;
2006-03-11 05:18:18 +01:00
request - > local_fileno = - 1 ;
request - > local_stream = NULL ;
2006-03-08 01:13:20 +01:00
request - > state = NEED_PUSH ;
2005-11-04 23:22:18 +01:00
request - > next = request_queue_head ;
request_queue_head = request ;
2005-11-18 20:02:58 +01:00
2006-06-06 18:41:32 +02:00
# ifdef USE_CURL_MULTI
2005-11-18 20:02:58 +01:00
fill_active_slots ( ) ;
step_active_slots ( ) ;
2006-06-06 18:41:32 +02:00
# endif
2006-03-11 05:18:33 +01:00
return 1 ;
2005-11-02 20:19:24 +01:00
}
static int fetch_index ( unsigned char * sha1 )
{
char * hex = sha1_to_hex ( sha1 ) ;
char * filename ;
char * url ;
char tmpfile [ PATH_MAX ] ;
long prev_posn = 0 ;
char range [ RANGE_HEADER_SIZE ] ;
struct curl_slist * range_header = NULL ;
FILE * indexfile ;
struct active_request_slot * slot ;
2006-03-11 05:18:01 +01:00
struct slot_results results ;
2005-11-02 20:19:24 +01:00
2005-11-04 23:22:18 +01:00
/* Don't use the index if the pack isn't there */
2006-03-11 05:18:33 +01:00
url = xmalloc ( strlen ( remote - > url ) + 64 ) ;
sprintf ( url , " %sobjects/pack/pack-%s.pack " , remote - > url , hex ) ;
2005-11-04 23:22:18 +01:00
slot = get_active_slot ( ) ;
2006-03-11 05:18:01 +01:00
slot - > results = & results ;
2005-11-04 23:22:18 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_URL , url ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_NOBODY , 1 ) ;
if ( start_active_slot ( slot ) ) {
run_active_slot ( slot ) ;
2006-03-11 05:18:01 +01:00
if ( results . curl_result ! = CURLE_OK ) {
2005-11-04 23:22:18 +01:00
free ( url ) ;
return error ( " Unable to verify pack %s is available " ,
hex ) ;
}
} else {
return error ( " Unable to start request " ) ;
}
2005-11-02 20:19:24 +01:00
if ( has_pack_index ( sha1 ) )
return 0 ;
if ( push_verbosely )
fprintf ( stderr , " Getting index for pack %s \n " , hex ) ;
2006-03-11 05:18:33 +01:00
sprintf ( url , " %sobjects/pack/pack-%s.idx " , remote - > url , hex ) ;
2005-11-02 20:19:24 +01:00
filename = sha1_pack_index_name ( sha1 ) ;
snprintf ( tmpfile , sizeof ( tmpfile ) , " %s.temp " , filename ) ;
indexfile = fopen ( tmpfile , " a " ) ;
if ( ! indexfile )
return error ( " Unable to open local file %s for pack index " ,
filename ) ;
slot = get_active_slot ( ) ;
2006-03-11 05:18:01 +01:00
slot - > results = & results ;
2005-11-04 23:22:18 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_NOBODY , 0 ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_HTTPGET , 1 ) ;
2005-11-02 20:19:24 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_FILE , indexfile ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_WRITEFUNCTION , fwrite ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_URL , url ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_HTTPHEADER , no_pragma_header ) ;
slot - > local = indexfile ;
/* If there is data present from a previous transfer attempt,
resume where it left off */
prev_posn = ftell ( indexfile ) ;
if ( prev_posn > 0 ) {
if ( push_verbosely )
fprintf ( stderr ,
" Resuming fetch of index for pack %s at byte %ld \n " ,
hex , prev_posn ) ;
sprintf ( range , " Range: bytes=%ld- " , prev_posn ) ;
range_header = curl_slist_append ( range_header , range ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_HTTPHEADER , range_header ) ;
}
if ( start_active_slot ( slot ) ) {
run_active_slot ( slot ) ;
2006-03-11 05:18:01 +01:00
if ( results . curl_result ! = CURLE_OK ) {
2005-11-02 20:19:24 +01:00
free ( url ) ;
fclose ( indexfile ) ;
return error ( " Unable to get pack index %s \n %s " , url ,
curl_errorstr ) ;
}
} else {
free ( url ) ;
2005-11-18 20:03:25 +01:00
fclose ( indexfile ) ;
2005-11-02 20:19:24 +01:00
return error ( " Unable to start request " ) ;
}
free ( url ) ;
fclose ( indexfile ) ;
return move_temp_to_file ( tmpfile , filename ) ;
}
static int setup_index ( unsigned char * sha1 )
{
struct packed_git * new_pack ;
if ( fetch_index ( sha1 ) )
return - 1 ;
new_pack = parse_pack_index ( sha1 ) ;
new_pack - > next = remote - > packs ;
remote - > packs = new_pack ;
return 0 ;
}
2005-11-08 23:18:31 +01:00
static int fetch_indices ( void )
2005-11-02 20:19:24 +01:00
{
unsigned char sha1 [ 20 ] ;
char * url ;
struct buffer buffer ;
char * data ;
int i = 0 ;
struct active_request_slot * slot ;
2006-03-11 05:18:01 +01:00
struct slot_results results ;
2005-11-02 20:19:24 +01:00
2006-04-03 20:30:46 +02:00
data = xcalloc ( 1 , 4096 ) ;
2005-11-02 20:19:24 +01:00
buffer . size = 4096 ;
buffer . posn = 0 ;
buffer . buffer = data ;
if ( push_verbosely )
fprintf ( stderr , " Getting pack list \n " ) ;
2006-03-11 05:18:33 +01:00
url = xmalloc ( strlen ( remote - > url ) + 20 ) ;
sprintf ( url , " %sobjects/info/packs " , remote - > url ) ;
2005-11-02 20:19:24 +01:00
slot = get_active_slot ( ) ;
2006-03-11 05:18:01 +01:00
slot - > results = & results ;
2005-11-02 20:19:24 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_FILE , & buffer ) ;
2005-11-18 20:02:58 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_WRITEFUNCTION , fwrite_buffer ) ;
2005-11-02 20:19:24 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_URL , url ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_HTTPHEADER , NULL ) ;
if ( start_active_slot ( slot ) ) {
run_active_slot ( slot ) ;
2006-03-11 05:18:01 +01:00
if ( results . curl_result ! = CURLE_OK ) {
2005-11-02 20:19:24 +01:00
free ( buffer . buffer ) ;
free ( url ) ;
2006-03-11 05:18:01 +01:00
if ( results . http_code = = 404 )
2005-11-02 20:19:24 +01:00
return 0 ;
else
return error ( " %s " , curl_errorstr ) ;
}
} else {
free ( buffer . buffer ) ;
free ( url ) ;
return error ( " Unable to start request " ) ;
}
free ( url ) ;
data = buffer . buffer ;
while ( i < buffer . posn ) {
switch ( data [ i ] ) {
case ' P ' :
i + + ;
if ( i + 52 < buffer . posn & &
! strncmp ( data + i , " pack- " , 6 ) & &
! strncmp ( data + i + 46 , " .pack \n " , 6 ) ) {
get_sha1_hex ( data + i + 6 , sha1 ) ;
setup_index ( sha1 ) ;
i + = 51 ;
break ;
}
default :
while ( data [ i ] ! = ' \n ' )
i + + ;
}
i + + ;
}
free ( buffer . buffer ) ;
return 0 ;
}
static inline int needs_quote ( int ch )
{
2006-06-18 17:18:03 +02:00
if ( ( ( ch > = ' A ' ) & & ( ch < = ' Z ' ) )
| | ( ( ch > = ' a ' ) & & ( ch < = ' z ' ) )
| | ( ( ch > = ' 0 ' ) & & ( ch < = ' 9 ' ) )
| | ( ch = = ' / ' )
| | ( ch = = ' - ' )
| | ( ch = = ' . ' ) )
2005-11-02 20:19:24 +01:00
return 0 ;
2006-06-18 17:18:03 +02:00
return 1 ;
2005-11-02 20:19:24 +01:00
}
static inline int hex ( int v )
{
if ( v < 10 ) return ' 0 ' + v ;
else return ' A ' + v - 10 ;
}
static char * quote_ref_url ( const char * base , const char * ref )
{
const char * cp ;
char * dp , * qref ;
int len , baselen , ch ;
baselen = strlen ( base ) ;
2006-03-08 01:13:20 +01:00
len = baselen + 1 ;
2005-11-02 20:19:24 +01:00
for ( cp = ref ; ( ch = * cp ) ! = 0 ; cp + + , len + + )
if ( needs_quote ( ch ) )
len + = 2 ; /* extra two hex plus replacement % */
qref = xmalloc ( len ) ;
memcpy ( qref , base , baselen ) ;
2006-03-08 01:13:20 +01:00
for ( cp = ref , dp = qref + baselen ; ( ch = * cp ) ! = 0 ; cp + + ) {
2005-11-02 20:19:24 +01:00
if ( needs_quote ( ch ) ) {
* dp + + = ' % ' ;
* dp + + = hex ( ( ch > > 4 ) & 0xF ) ;
* dp + + = hex ( ch & 0xF ) ;
}
else
* dp + + = ch ;
}
* dp = 0 ;
return qref ;
}
int fetch_ref ( char * ref , unsigned char * sha1 )
{
char * url ;
char hex [ 42 ] ;
struct buffer buffer ;
char * base = remote - > url ;
struct active_request_slot * slot ;
2006-03-11 05:18:01 +01:00
struct slot_results results ;
2005-11-02 20:19:24 +01:00
buffer . size = 41 ;
buffer . posn = 0 ;
buffer . buffer = hex ;
hex [ 41 ] = ' \0 ' ;
2006-03-11 05:18:01 +01:00
2005-11-02 20:19:24 +01:00
url = quote_ref_url ( base , ref ) ;
slot = get_active_slot ( ) ;
2006-03-11 05:18:01 +01:00
slot - > results = & results ;
2005-11-02 20:19:24 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_FILE , & buffer ) ;
2005-11-18 20:02:58 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_WRITEFUNCTION , fwrite_buffer ) ;
2005-11-02 20:19:24 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_HTTPHEADER , NULL ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_URL , url ) ;
if ( start_active_slot ( slot ) ) {
run_active_slot ( slot ) ;
2006-03-11 05:18:01 +01:00
if ( results . curl_result ! = CURLE_OK )
2005-11-02 20:19:24 +01:00
return error ( " Couldn't get %s for %s \n %s " ,
url , ref , curl_errorstr ) ;
} else {
return error ( " Unable to start request " ) ;
}
hex [ 40 ] = ' \0 ' ;
get_sha1_hex ( hex , sha1 ) ;
return 0 ;
}
2006-03-08 01:13:20 +01:00
static void one_remote_object ( const char * hex )
{
unsigned char sha1 [ 20 ] ;
struct object * obj ;
if ( get_sha1_hex ( hex , sha1 ) ! = 0 )
return ;
obj = lookup_object ( sha1 ) ;
if ( ! obj )
obj = parse_object ( sha1 ) ;
/* Ignore remote objects that don't exist locally */
if ( ! obj )
return ;
obj - > flags | = REMOTE ;
if ( ! object_list_contains ( objects , obj ) )
Add "named object array" concept
We've had this notion of a "object_list" for a long time, which eventually
grew a "name" member because some users (notably git-rev-list) wanted to
name each object as it is generated.
That object_list is great for some things, but it isn't all that wonderful
for others, and the "name" member is generally not used by everybody.
This patch splits the users of the object_list array up into two: the
traditional list users, who want the list-like format, and who don't
actually use or want the name. And another class of users that really used
the list as an extensible array, and generally wanted to name the objects.
The patch is fairly straightforward, but it's also biggish. Most of it
really just cleans things up: switching the revision parsing and listing
over to the array makes things like the builtin-diff usage much simpler
(we now see exactly how many members the array has, and we don't get the
objects reversed from the order they were on the command line).
One of the main reasons for doing this at all is that the malloc overhead
of the simple object list was actually pretty high, and the array is just
a lot denser. So this patch brings down memory usage by git-rev-list by
just under 3% (on top of all the other memory use optimizations) on the
mozilla archive.
It does add more lines than it removes, and more importantly, it adds a
whole new infrastructure for maintaining lists of objects, but on the
other hand, the new dynamic array code is pretty obvious. The change to
builtin-diff-tree.c shows a fairly good example of why an array interface
is sometimes more natural, and just much simpler for everybody.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-20 02:42:35 +02:00
object_list_insert ( obj , & objects ) ;
2006-03-08 01:13:20 +01:00
}
2005-11-18 20:03:18 +01:00
static void handle_lockprop_ctx ( struct xml_ctx * ctx , int tag_closed )
2005-11-04 23:22:31 +01:00
{
2005-11-18 20:03:18 +01:00
int * lock_flags = ( int * ) ctx - > userData ;
if ( tag_closed ) {
if ( ! strcmp ( ctx - > name , DAV_CTX_LOCKENTRY ) ) {
if ( ( * lock_flags & DAV_PROP_LOCKEX ) & &
( * lock_flags & DAV_PROP_LOCKWR ) ) {
* lock_flags | = DAV_LOCK_OK ;
}
* lock_flags & = DAV_LOCK_OK ;
} else if ( ! strcmp ( ctx - > name , DAV_CTX_LOCKTYPE_WRITE ) ) {
* lock_flags | = DAV_PROP_LOCKWR ;
} else if ( ! strcmp ( ctx - > name , DAV_CTX_LOCKTYPE_EXCLUSIVE ) ) {
* lock_flags | = DAV_PROP_LOCKEX ;
}
}
2005-11-04 23:22:31 +01:00
}
2005-11-18 20:03:18 +01:00
static void handle_new_lock_ctx ( struct xml_ctx * ctx , int tag_closed )
2005-11-04 23:22:31 +01:00
{
2006-03-08 01:13:20 +01:00
struct remote_lock * lock = ( struct remote_lock * ) ctx - > userData ;
2005-11-18 20:03:18 +01:00
if ( tag_closed & & ctx - > cdata ) {
if ( ! strcmp ( ctx - > name , DAV_ACTIVELOCK_OWNER ) ) {
lock - > owner = xmalloc ( strlen ( ctx - > cdata ) + 1 ) ;
strcpy ( lock - > owner , ctx - > cdata ) ;
} else if ( ! strcmp ( ctx - > name , DAV_ACTIVELOCK_TIMEOUT ) ) {
if ( ! strncmp ( ctx - > cdata , " Second- " , 7 ) )
lock - > timeout =
strtol ( ctx - > cdata + 7 , NULL , 10 ) ;
} else if ( ! strcmp ( ctx - > name , DAV_ACTIVELOCK_TOKEN ) ) {
if ( ! strncmp ( ctx - > cdata , " opaquelocktoken: " , 16 ) ) {
2005-11-29 01:51:54 +01:00
lock - > token = xmalloc ( strlen ( ctx - > cdata ) - 15 ) ;
2005-11-18 20:03:18 +01:00
strcpy ( lock - > token , ctx - > cdata + 16 ) ;
}
}
2005-11-04 23:22:31 +01:00
}
}
2006-03-08 01:13:20 +01:00
static void one_remote_ref ( char * refname ) ;
2005-11-04 23:22:31 +01:00
static void
2005-11-18 20:03:18 +01:00
xml_start_tag ( void * userData , const char * name , const char * * atts )
2005-11-04 23:22:31 +01:00
{
2005-11-18 20:03:18 +01:00
struct xml_ctx * ctx = ( struct xml_ctx * ) userData ;
2006-04-11 18:37:58 +02:00
const char * c = strchr ( name , ' : ' ) ;
2005-11-18 20:03:18 +01:00
int new_len ;
if ( c = = NULL )
c = name ;
else
c + + ;
new_len = strlen ( ctx - > name ) + strlen ( c ) + 2 ;
if ( new_len > ctx - > len ) {
ctx - > name = xrealloc ( ctx - > name , new_len ) ;
ctx - > len = new_len ;
2005-11-04 23:22:31 +01:00
}
2005-11-18 20:03:18 +01:00
strcat ( ctx - > name , " . " ) ;
strcat ( ctx - > name , c ) ;
2005-11-04 23:22:31 +01:00
2005-11-18 20:03:18 +01:00
if ( ctx - > cdata ) {
free ( ctx - > cdata ) ;
ctx - > cdata = NULL ;
}
ctx - > userFunc ( ctx , 0 ) ;
2005-11-04 23:22:31 +01:00
}
2005-11-02 20:19:24 +01:00
static void
2005-11-18 20:03:18 +01:00
xml_end_tag ( void * userData , const char * name )
2005-11-02 20:19:24 +01:00
{
2005-11-18 20:03:18 +01:00
struct xml_ctx * ctx = ( struct xml_ctx * ) userData ;
2006-04-11 18:37:58 +02:00
const char * c = strchr ( name , ' : ' ) ;
2005-11-18 20:03:18 +01:00
char * ep ;
2005-11-02 20:19:24 +01:00
2005-11-18 20:03:18 +01:00
ctx - > userFunc ( ctx , 1 ) ;
if ( c = = NULL )
c = name ;
else
c + + ;
ep = ctx - > name + strlen ( ctx - > name ) - strlen ( c ) - 1 ;
* ep = 0 ;
2005-11-02 20:19:24 +01:00
}
static void
2005-11-18 20:03:18 +01:00
xml_cdata ( void * userData , const XML_Char * s , int len )
2005-11-02 20:19:24 +01:00
{
2005-11-18 20:03:18 +01:00
struct xml_ctx * ctx = ( struct xml_ctx * ) userData ;
if ( ctx - > cdata )
free ( ctx - > cdata ) ;
2006-06-11 14:03:28 +02:00
ctx - > cdata = xmalloc ( len + 1 ) ;
2006-06-24 16:01:25 +02:00
strlcpy ( ctx - > cdata , s , len + 1 ) ;
2005-11-02 20:19:24 +01:00
}
2006-06-28 11:04:39 +02:00
static struct remote_lock * lock_remote ( const char * path , long timeout )
2005-11-02 20:19:24 +01:00
{
struct active_request_slot * slot ;
2006-03-11 05:18:01 +01:00
struct slot_results results ;
2005-11-02 20:19:24 +01:00
struct buffer out_buffer ;
2005-11-04 23:22:31 +01:00
struct buffer in_buffer ;
2005-11-02 20:19:24 +01:00
char * out_data ;
2005-11-04 23:22:31 +01:00
char * in_data ;
2005-11-02 20:19:24 +01:00
char * url ;
2005-11-04 23:22:25 +01:00
char * ep ;
2005-11-02 20:19:24 +01:00
char timeout_header [ 25 ] ;
2006-03-11 05:18:12 +01:00
struct remote_lock * lock = NULL ;
2005-11-04 23:22:31 +01:00
XML_Parser parser = XML_ParserCreate ( NULL ) ;
enum XML_Status result ;
2005-11-02 20:19:24 +01:00
struct curl_slist * dav_headers = NULL ;
2005-11-18 20:03:18 +01:00
struct xml_ctx ctx ;
2005-11-02 20:19:24 +01:00
2006-03-08 01:13:20 +01:00
url = xmalloc ( strlen ( remote - > url ) + strlen ( path ) + 1 ) ;
sprintf ( url , " %s%s " , remote - > url , path ) ;
2005-11-04 23:22:25 +01:00
/* Make sure leading directories exist for the remote ref */
ep = strchr ( url + strlen ( remote - > url ) + 11 , ' / ' ) ;
while ( ep ) {
* ep = 0 ;
slot = get_active_slot ( ) ;
2006-03-11 05:18:01 +01:00
slot - > results = & results ;
2005-11-04 23:22:25 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_HTTPGET , 1 ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_URL , url ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_CUSTOMREQUEST , DAV_MKCOL ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_WRITEFUNCTION , fwrite_null ) ;
if ( start_active_slot ( slot ) ) {
run_active_slot ( slot ) ;
2006-03-11 05:18:01 +01:00
if ( results . curl_result ! = CURLE_OK & &
results . http_code ! = 405 ) {
2005-11-04 23:22:25 +01:00
fprintf ( stderr ,
" Unable to create branch path %s \n " ,
url ) ;
free ( url ) ;
return NULL ;
}
} else {
2006-03-11 05:18:33 +01:00
fprintf ( stderr , " Unable to start MKCOL request \n " ) ;
2005-11-04 23:22:25 +01:00
free ( url ) ;
return NULL ;
}
* ep = ' / ' ;
ep = strchr ( ep + 1 , ' / ' ) ;
}
2005-11-02 20:19:24 +01:00
out_buffer . size = strlen ( LOCK_REQUEST ) + strlen ( git_default_email ) - 2 ;
out_data = xmalloc ( out_buffer . size + 1 ) ;
snprintf ( out_data , out_buffer . size + 1 , LOCK_REQUEST , git_default_email ) ;
out_buffer . posn = 0 ;
out_buffer . buffer = out_data ;
2005-11-04 23:22:31 +01:00
in_buffer . size = 4096 ;
in_data = xmalloc ( in_buffer . size ) ;
in_buffer . posn = 0 ;
in_buffer . buffer = in_data ;
2005-11-04 23:22:35 +01:00
sprintf ( timeout_header , " Timeout: Second-%ld " , timeout ) ;
2005-11-02 20:19:24 +01:00
dav_headers = curl_slist_append ( dav_headers , timeout_header ) ;
dav_headers = curl_slist_append ( dav_headers , " Content-Type: text/xml " ) ;
slot = get_active_slot ( ) ;
2006-03-11 05:18:01 +01:00
slot - > results = & results ;
2005-11-02 20:19:24 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_INFILE , & out_buffer ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_INFILESIZE , out_buffer . size ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_READFUNCTION , fread_buffer ) ;
2005-11-04 23:22:31 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_FILE , & in_buffer ) ;
2005-11-18 20:02:58 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_WRITEFUNCTION , fwrite_buffer ) ;
2005-11-02 20:19:24 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_URL , url ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_UPLOAD , 1 ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_CUSTOMREQUEST , DAV_LOCK ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_HTTPHEADER , dav_headers ) ;
2006-03-08 01:13:20 +01:00
lock = xcalloc ( 1 , sizeof ( * lock ) ) ;
lock - > timeout = - 1 ;
2005-11-18 20:03:18 +01:00
2005-11-02 20:19:24 +01:00
if ( start_active_slot ( slot ) ) {
run_active_slot ( slot ) ;
2006-03-11 05:18:01 +01:00
if ( results . curl_result = = CURLE_OK ) {
2005-11-18 20:03:18 +01:00
ctx . name = xcalloc ( 10 , 1 ) ;
ctx . len = 0 ;
ctx . cdata = NULL ;
ctx . userFunc = handle_new_lock_ctx ;
2006-03-08 01:13:20 +01:00
ctx . userData = lock ;
2005-11-18 20:03:18 +01:00
XML_SetUserData ( parser , & ctx ) ;
XML_SetElementHandler ( parser , xml_start_tag ,
xml_end_tag ) ;
XML_SetCharacterDataHandler ( parser , xml_cdata ) ;
result = XML_Parse ( parser , in_buffer . buffer ,
in_buffer . posn , 1 ) ;
free ( ctx . name ) ;
if ( result ! = XML_STATUS_OK ) {
fprintf ( stderr , " XML error: %s \n " ,
XML_ErrorString (
XML_GetErrorCode ( parser ) ) ) ;
2006-03-08 01:13:20 +01:00
lock - > timeout = - 1 ;
2005-11-18 20:03:18 +01:00
}
2005-11-02 20:19:24 +01:00
}
} else {
2006-03-11 05:18:33 +01:00
fprintf ( stderr , " Unable to start LOCK request \n " ) ;
2005-11-02 20:19:24 +01:00
}
2005-11-18 20:03:18 +01:00
curl_slist_free_all ( dav_headers ) ;
2005-11-04 23:22:25 +01:00
free ( out_data ) ;
2005-11-04 23:22:31 +01:00
free ( in_data ) ;
2006-03-08 01:13:20 +01:00
if ( lock - > token = = NULL | | lock - > timeout < = 0 ) {
if ( lock - > token ! = NULL )
free ( lock - > token ) ;
if ( lock - > owner ! = NULL )
free ( lock - > owner ) ;
2005-11-04 23:22:35 +01:00
free ( url ) ;
2006-03-08 01:13:20 +01:00
free ( lock ) ;
lock = NULL ;
2005-11-18 20:03:18 +01:00
} else {
2006-03-08 01:13:20 +01:00
lock - > url = url ;
lock - > start_time = time ( NULL ) ;
2006-03-11 05:18:12 +01:00
lock - > next = remote - > locks ;
remote - > locks = lock ;
2005-11-04 23:22:31 +01:00
}
2006-03-08 01:13:20 +01:00
return lock ;
2005-11-02 20:19:24 +01:00
}
2006-03-08 01:13:20 +01:00
static int unlock_remote ( struct remote_lock * lock )
2005-11-02 20:19:24 +01:00
{
struct active_request_slot * slot ;
2006-03-11 05:18:01 +01:00
struct slot_results results ;
2006-03-11 05:18:12 +01:00
struct remote_lock * prev = remote - > locks ;
2005-11-02 20:19:24 +01:00
char * lock_token_header ;
struct curl_slist * dav_headers = NULL ;
int rc = 0 ;
2005-11-04 23:22:31 +01:00
lock_token_header = xmalloc ( strlen ( lock - > token ) + 31 ) ;
2005-11-02 20:19:24 +01:00
sprintf ( lock_token_header , " Lock-Token: <opaquelocktoken:%s> " ,
2005-11-04 23:22:31 +01:00
lock - > token ) ;
2005-11-02 20:19:24 +01:00
dav_headers = curl_slist_append ( dav_headers , lock_token_header ) ;
slot = get_active_slot ( ) ;
2006-03-11 05:18:01 +01:00
slot - > results = & results ;
2005-11-02 20:19:24 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_WRITEFUNCTION , fwrite_null ) ;
2005-11-04 23:22:35 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_URL , lock - > url ) ;
2005-11-02 20:19:24 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_CUSTOMREQUEST , DAV_UNLOCK ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_HTTPHEADER , dav_headers ) ;
if ( start_active_slot ( slot ) ) {
run_active_slot ( slot ) ;
2006-03-11 05:18:01 +01:00
if ( results . curl_result = = CURLE_OK )
2005-11-02 20:19:24 +01:00
rc = 1 ;
else
2006-03-11 05:18:12 +01:00
fprintf ( stderr , " UNLOCK HTTP error %ld \n " ,
2006-03-11 05:18:01 +01:00
results . http_code ) ;
2005-11-02 20:19:24 +01:00
} else {
2006-03-11 05:18:12 +01:00
fprintf ( stderr , " Unable to start UNLOCK request \n " ) ;
2005-11-02 20:19:24 +01:00
}
curl_slist_free_all ( dav_headers ) ;
free ( lock_token_header ) ;
2005-11-04 23:22:35 +01:00
2006-03-11 05:18:12 +01:00
if ( remote - > locks = = lock ) {
remote - > locks = lock - > next ;
} else {
while ( prev & & prev - > next ! = lock )
prev = prev - > next ;
if ( prev )
prev - > next = prev - > next - > next ;
}
if ( lock - > owner ! = NULL )
free ( lock - > owner ) ;
free ( lock - > url ) ;
free ( lock - > token ) ;
free ( lock ) ;
2005-11-02 20:19:24 +01:00
return rc ;
}
2006-03-11 05:18:08 +01:00
static void remote_ls ( const char * path , int flags ,
void ( * userFunc ) ( struct remote_ls_ctx * ls ) ,
void * userData ) ;
2006-03-08 01:13:20 +01:00
2006-03-11 05:18:08 +01:00
static void process_ls_object ( struct remote_ls_ctx * ls )
{
unsigned int * parent = ( unsigned int * ) ls - > userData ;
char * path = ls - > dentry_name ;
char * obj_hex ;
2006-03-08 01:13:20 +01:00
2006-03-11 05:18:08 +01:00
if ( ! strcmp ( ls - > path , ls - > dentry_name ) & & ( ls - > flags & IS_DIR ) ) {
remote_dir_exists [ * parent ] = 1 ;
return ;
}
2006-03-08 01:13:20 +01:00
2006-03-11 05:18:08 +01:00
if ( strlen ( path ) ! = 49 )
return ;
path + = 8 ;
obj_hex = xmalloc ( strlen ( path ) ) ;
2006-06-24 16:01:25 +02:00
strlcpy ( obj_hex , path , 3 ) ;
2006-03-11 05:18:08 +01:00
strcpy ( obj_hex + 2 , path + 3 ) ;
one_remote_object ( obj_hex ) ;
free ( obj_hex ) ;
}
2006-03-08 01:13:20 +01:00
2006-03-11 05:18:08 +01:00
static void process_ls_ref ( struct remote_ls_ctx * ls )
{
if ( ! strcmp ( ls - > path , ls - > dentry_name ) & & ( ls - > dentry_flags & IS_DIR ) ) {
fprintf ( stderr , " %s \n " , ls - > dentry_name ) ;
return ;
}
2006-03-08 01:13:20 +01:00
2006-03-11 05:18:08 +01:00
if ( ! ( ls - > dentry_flags & IS_DIR ) )
one_remote_ref ( ls - > dentry_name ) ;
}
2006-03-08 01:13:20 +01:00
2006-03-11 05:18:08 +01:00
static void handle_remote_ls_ctx ( struct xml_ctx * ctx , int tag_closed )
{
struct remote_ls_ctx * ls = ( struct remote_ls_ctx * ) ctx - > userData ;
2006-03-08 01:13:20 +01:00
2006-03-11 05:18:08 +01:00
if ( tag_closed ) {
if ( ! strcmp ( ctx - > name , DAV_PROPFIND_RESP ) & & ls - > dentry_name ) {
if ( ls - > dentry_flags & IS_DIR ) {
if ( ls - > flags & PROCESS_DIRS ) {
ls - > userFunc ( ls ) ;
}
if ( strcmp ( ls - > dentry_name , ls - > path ) & &
ls - > flags & RECURSIVE ) {
remote_ls ( ls - > dentry_name ,
ls - > flags ,
ls - > userFunc ,
ls - > userData ) ;
}
} else if ( ls - > flags & PROCESS_FILES ) {
ls - > userFunc ( ls ) ;
2006-03-08 01:13:20 +01:00
}
2006-03-11 05:18:08 +01:00
} else if ( ! strcmp ( ctx - > name , DAV_PROPFIND_NAME ) & & ctx - > cdata ) {
ls - > dentry_name = xmalloc ( strlen ( ctx - > cdata ) -
remote - > path_len + 1 ) ;
strcpy ( ls - > dentry_name , ctx - > cdata + remote - > path_len ) ;
} else if ( ! strcmp ( ctx - > name , DAV_PROPFIND_COLLECTION ) ) {
ls - > dentry_flags | = IS_DIR ;
2006-03-08 01:13:20 +01:00
}
2006-03-11 05:18:08 +01:00
} else if ( ! strcmp ( ctx - > name , DAV_PROPFIND_RESP ) ) {
if ( ls - > dentry_name ) {
free ( ls - > dentry_name ) ;
}
ls - > dentry_name = NULL ;
ls - > dentry_flags = 0 ;
2006-03-08 01:13:20 +01:00
}
}
2006-03-11 05:18:08 +01:00
static void remote_ls ( const char * path , int flags ,
void ( * userFunc ) ( struct remote_ls_ctx * ls ) ,
void * userData )
2006-03-08 01:13:20 +01:00
{
2006-03-11 05:18:08 +01:00
char * url = xmalloc ( strlen ( remote - > url ) + strlen ( path ) + 1 ) ;
2006-03-08 01:13:20 +01:00
struct active_request_slot * slot ;
2006-03-11 05:18:01 +01:00
struct slot_results results ;
2006-03-08 01:13:20 +01:00
struct buffer in_buffer ;
struct buffer out_buffer ;
char * in_data ;
char * out_data ;
XML_Parser parser = XML_ParserCreate ( NULL ) ;
enum XML_Status result ;
struct curl_slist * dav_headers = NULL ;
struct xml_ctx ctx ;
2006-03-11 05:18:08 +01:00
struct remote_ls_ctx ls ;
ls . flags = flags ;
ls . path = strdup ( path ) ;
ls . dentry_name = NULL ;
ls . dentry_flags = 0 ;
ls . userData = userData ;
ls . userFunc = userFunc ;
2006-03-08 01:13:20 +01:00
sprintf ( url , " %s%s " , remote - > url , path ) ;
out_buffer . size = strlen ( PROPFIND_ALL_REQUEST ) ;
out_data = xmalloc ( out_buffer . size + 1 ) ;
snprintf ( out_data , out_buffer . size + 1 , PROPFIND_ALL_REQUEST ) ;
out_buffer . posn = 0 ;
out_buffer . buffer = out_data ;
in_buffer . size = 4096 ;
in_data = xmalloc ( in_buffer . size ) ;
in_buffer . posn = 0 ;
in_buffer . buffer = in_data ;
dav_headers = curl_slist_append ( dav_headers , " Depth: 1 " ) ;
dav_headers = curl_slist_append ( dav_headers , " Content-Type: text/xml " ) ;
slot = get_active_slot ( ) ;
2006-03-11 05:18:01 +01:00
slot - > results = & results ;
2006-03-08 01:13:20 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_INFILE , & out_buffer ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_INFILESIZE , out_buffer . size ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_READFUNCTION , fread_buffer ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_FILE , & in_buffer ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_WRITEFUNCTION , fwrite_buffer ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_URL , url ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_UPLOAD , 1 ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_CUSTOMREQUEST , DAV_PROPFIND ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_HTTPHEADER , dav_headers ) ;
if ( start_active_slot ( slot ) ) {
run_active_slot ( slot ) ;
2006-03-11 05:18:01 +01:00
if ( results . curl_result = = CURLE_OK ) {
2006-03-08 01:13:20 +01:00
ctx . name = xcalloc ( 10 , 1 ) ;
ctx . len = 0 ;
ctx . cdata = NULL ;
2006-03-11 05:18:08 +01:00
ctx . userFunc = handle_remote_ls_ctx ;
ctx . userData = & ls ;
2006-03-08 01:13:20 +01:00
XML_SetUserData ( parser , & ctx ) ;
XML_SetElementHandler ( parser , xml_start_tag ,
xml_end_tag ) ;
XML_SetCharacterDataHandler ( parser , xml_cdata ) ;
result = XML_Parse ( parser , in_buffer . buffer ,
in_buffer . posn , 1 ) ;
free ( ctx . name ) ;
if ( result ! = XML_STATUS_OK ) {
fprintf ( stderr , " XML error: %s \n " ,
XML_ErrorString (
XML_GetErrorCode ( parser ) ) ) ;
}
}
} else {
2006-03-11 05:18:08 +01:00
fprintf ( stderr , " Unable to start PROPFIND request \n " ) ;
2006-03-08 01:13:20 +01:00
}
2006-03-11 05:18:08 +01:00
free ( ls . path ) ;
2006-03-08 01:13:20 +01:00
free ( url ) ;
free ( out_data ) ;
free ( in_buffer . buffer ) ;
curl_slist_free_all ( dav_headers ) ;
}
2006-03-11 05:18:08 +01:00
static void get_remote_object_list ( unsigned char parent )
{
char path [ ] = " objects/XX/ " ;
static const char hex [ ] = " 0123456789abcdef " ;
unsigned int val = parent ;
path [ 8 ] = hex [ val > > 4 ] ;
path [ 9 ] = hex [ val & 0xf ] ;
remote_dir_exists [ val ] = 0 ;
remote_ls ( path , ( PROCESS_FILES | PROCESS_DIRS ) ,
process_ls_object , & val ) ;
}
2005-11-18 20:03:18 +01:00
static int locking_available ( void )
2005-11-02 20:19:24 +01:00
{
struct active_request_slot * slot ;
2006-03-11 05:18:01 +01:00
struct slot_results results ;
2005-11-02 20:19:24 +01:00
struct buffer in_buffer ;
struct buffer out_buffer ;
char * in_data ;
char * out_data ;
XML_Parser parser = XML_ParserCreate ( NULL ) ;
enum XML_Status result ;
struct curl_slist * dav_headers = NULL ;
2005-11-18 20:03:18 +01:00
struct xml_ctx ctx ;
int lock_flags = 0 ;
2005-11-02 20:19:24 +01:00
2006-03-08 01:13:20 +01:00
out_buffer . size =
strlen ( PROPFIND_SUPPORTEDLOCK_REQUEST ) +
strlen ( remote - > url ) - 2 ;
2005-11-02 20:19:24 +01:00
out_data = xmalloc ( out_buffer . size + 1 ) ;
2006-03-08 01:13:20 +01:00
snprintf ( out_data , out_buffer . size + 1 ,
PROPFIND_SUPPORTEDLOCK_REQUEST , remote - > url ) ;
2005-11-02 20:19:24 +01:00
out_buffer . posn = 0 ;
out_buffer . buffer = out_data ;
in_buffer . size = 4096 ;
in_data = xmalloc ( in_buffer . size ) ;
in_buffer . posn = 0 ;
in_buffer . buffer = in_data ;
dav_headers = curl_slist_append ( dav_headers , " Depth: 0 " ) ;
dav_headers = curl_slist_append ( dav_headers , " Content-Type: text/xml " ) ;
2006-03-11 05:18:01 +01:00
2005-11-02 20:19:24 +01:00
slot = get_active_slot ( ) ;
2006-03-11 05:18:01 +01:00
slot - > results = & results ;
2005-11-02 20:19:24 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_INFILE , & out_buffer ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_INFILESIZE , out_buffer . size ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_READFUNCTION , fread_buffer ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_FILE , & in_buffer ) ;
2005-11-18 20:02:58 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_WRITEFUNCTION , fwrite_buffer ) ;
2005-11-02 20:19:24 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_URL , remote - > url ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_UPLOAD , 1 ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_CUSTOMREQUEST , DAV_PROPFIND ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_HTTPHEADER , dav_headers ) ;
if ( start_active_slot ( slot ) ) {
run_active_slot ( slot ) ;
2006-03-11 05:18:01 +01:00
if ( results . curl_result = = CURLE_OK ) {
2005-11-18 20:03:18 +01:00
ctx . name = xcalloc ( 10 , 1 ) ;
ctx . len = 0 ;
ctx . cdata = NULL ;
ctx . userFunc = handle_lockprop_ctx ;
ctx . userData = & lock_flags ;
XML_SetUserData ( parser , & ctx ) ;
XML_SetElementHandler ( parser , xml_start_tag ,
xml_end_tag ) ;
result = XML_Parse ( parser , in_buffer . buffer ,
in_buffer . posn , 1 ) ;
free ( ctx . name ) ;
if ( result ! = XML_STATUS_OK ) {
fprintf ( stderr , " XML error: %s \n " ,
XML_ErrorString (
XML_GetErrorCode ( parser ) ) ) ;
lock_flags = 0 ;
}
2005-11-02 20:19:24 +01:00
}
} else {
2006-03-11 05:18:33 +01:00
fprintf ( stderr , " Unable to start PROPFIND request \n " ) ;
2005-11-02 20:19:24 +01:00
}
2005-11-18 20:03:18 +01:00
free ( out_data ) ;
free ( in_buffer . buffer ) ;
curl_slist_free_all ( dav_headers ) ;
return lock_flags ;
2005-11-02 20:19:24 +01:00
}
Add "named object array" concept
We've had this notion of a "object_list" for a long time, which eventually
grew a "name" member because some users (notably git-rev-list) wanted to
name each object as it is generated.
That object_list is great for some things, but it isn't all that wonderful
for others, and the "name" member is generally not used by everybody.
This patch splits the users of the object_list array up into two: the
traditional list users, who want the list-like format, and who don't
actually use or want the name. And another class of users that really used
the list as an extensible array, and generally wanted to name the objects.
The patch is fairly straightforward, but it's also biggish. Most of it
really just cleans things up: switching the revision parsing and listing
over to the array makes things like the builtin-diff usage much simpler
(we now see exactly how many members the array has, and we don't get the
objects reversed from the order they were on the command line).
One of the main reasons for doing this at all is that the malloc overhead
of the simple object list was actually pretty high, and the array is just
a lot denser. So this patch brings down memory usage by git-rev-list by
just under 3% (on top of all the other memory use optimizations) on the
mozilla archive.
It does add more lines than it removes, and more importantly, it adds a
whole new infrastructure for maintaining lists of objects, but on the
other hand, the new dynamic array code is pretty obvious. The change to
builtin-diff-tree.c shows a fairly good example of why an array interface
is sometimes more natural, and just much simpler for everybody.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-20 02:42:35 +02:00
struct object_list * * add_one_object ( struct object * obj , struct object_list * * p )
{
struct object_list * entry = xmalloc ( sizeof ( struct object_list ) ) ;
entry - > item = obj ;
entry - > next = * p ;
* p = entry ;
return & entry - > next ;
}
2006-03-08 01:13:20 +01:00
static struct object_list * * process_blob ( struct blob * blob ,
struct object_list * * p ,
struct name_path * path ,
const char * name )
2005-11-02 20:19:24 +01:00
{
2006-03-08 01:13:20 +01:00
struct object * obj = & blob - > object ;
2005-11-02 20:19:24 +01:00
2006-03-08 01:13:20 +01:00
obj - > flags | = LOCAL ;
if ( obj - > flags & ( UNINTERESTING | SEEN ) )
return p ;
obj - > flags | = SEEN ;
Add "named object array" concept
We've had this notion of a "object_list" for a long time, which eventually
grew a "name" member because some users (notably git-rev-list) wanted to
name each object as it is generated.
That object_list is great for some things, but it isn't all that wonderful
for others, and the "name" member is generally not used by everybody.
This patch splits the users of the object_list array up into two: the
traditional list users, who want the list-like format, and who don't
actually use or want the name. And another class of users that really used
the list as an extensible array, and generally wanted to name the objects.
The patch is fairly straightforward, but it's also biggish. Most of it
really just cleans things up: switching the revision parsing and listing
over to the array makes things like the builtin-diff usage much simpler
(we now see exactly how many members the array has, and we don't get the
objects reversed from the order they were on the command line).
One of the main reasons for doing this at all is that the malloc overhead
of the simple object list was actually pretty high, and the array is just
a lot denser. So this patch brings down memory usage by git-rev-list by
just under 3% (on top of all the other memory use optimizations) on the
mozilla archive.
It does add more lines than it removes, and more importantly, it adds a
whole new infrastructure for maintaining lists of objects, but on the
other hand, the new dynamic array code is pretty obvious. The change to
builtin-diff-tree.c shows a fairly good example of why an array interface
is sometimes more natural, and just much simpler for everybody.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-20 02:42:35 +02:00
return add_one_object ( obj , p ) ;
2006-03-08 01:13:20 +01:00
}
static struct object_list * * process_tree ( struct tree * tree ,
struct object_list * * p ,
struct name_path * path ,
const char * name )
{
struct object * obj = & tree - > object ;
2006-05-29 21:18:33 +02:00
struct tree_desc desc ;
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-30 18:45:45 +02:00
struct name_entry entry ;
2006-03-08 01:13:20 +01:00
struct name_path me ;
obj - > flags | = LOCAL ;
if ( obj - > flags & ( UNINTERESTING | SEEN ) )
return p ;
if ( parse_tree ( tree ) < 0 )
die ( " bad tree object %s " , sha1_to_hex ( obj - > sha1 ) ) ;
obj - > flags | = SEEN ;
2006-05-29 21:18:33 +02:00
name = strdup ( name ) ;
Add "named object array" concept
We've had this notion of a "object_list" for a long time, which eventually
grew a "name" member because some users (notably git-rev-list) wanted to
name each object as it is generated.
That object_list is great for some things, but it isn't all that wonderful
for others, and the "name" member is generally not used by everybody.
This patch splits the users of the object_list array up into two: the
traditional list users, who want the list-like format, and who don't
actually use or want the name. And another class of users that really used
the list as an extensible array, and generally wanted to name the objects.
The patch is fairly straightforward, but it's also biggish. Most of it
really just cleans things up: switching the revision parsing and listing
over to the array makes things like the builtin-diff usage much simpler
(we now see exactly how many members the array has, and we don't get the
objects reversed from the order they were on the command line).
One of the main reasons for doing this at all is that the malloc overhead
of the simple object list was actually pretty high, and the array is just
a lot denser. So this patch brings down memory usage by git-rev-list by
just under 3% (on top of all the other memory use optimizations) on the
mozilla archive.
It does add more lines than it removes, and more importantly, it adds a
whole new infrastructure for maintaining lists of objects, but on the
other hand, the new dynamic array code is pretty obvious. The change to
builtin-diff-tree.c shows a fairly good example of why an array interface
is sometimes more natural, and just much simpler for everybody.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-20 02:42:35 +02:00
p = add_one_object ( obj , p ) ;
2006-03-08 01:13:20 +01:00
me . up = path ;
me . elem = name ;
me . elem_len = strlen ( name ) ;
2006-05-29 21:18:33 +02:00
desc . buf = tree - > buffer ;
desc . size = tree - > size ;
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-30 18:45:45 +02:00
while ( tree_entry ( & desc , & entry ) ) {
if ( S_ISDIR ( entry . mode ) )
p = process_tree ( lookup_tree ( entry . sha1 ) , p , & me , name ) ;
2006-03-08 01:13:20 +01:00
else
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-30 18:45:45 +02:00
p = process_blob ( lookup_blob ( entry . sha1 ) , p , & me , name ) ;
2005-11-02 20:19:24 +01:00
}
2006-05-29 21:18:33 +02:00
free ( tree - > buffer ) ;
tree - > buffer = NULL ;
2006-03-08 01:13:20 +01:00
return p ;
2005-11-02 20:19:24 +01:00
}
2006-03-11 05:18:33 +01:00
static int get_delta ( struct rev_info * revs , struct remote_lock * lock )
2005-11-02 20:19:24 +01:00
{
Add "named object array" concept
We've had this notion of a "object_list" for a long time, which eventually
grew a "name" member because some users (notably git-rev-list) wanted to
name each object as it is generated.
That object_list is great for some things, but it isn't all that wonderful
for others, and the "name" member is generally not used by everybody.
This patch splits the users of the object_list array up into two: the
traditional list users, who want the list-like format, and who don't
actually use or want the name. And another class of users that really used
the list as an extensible array, and generally wanted to name the objects.
The patch is fairly straightforward, but it's also biggish. Most of it
really just cleans things up: switching the revision parsing and listing
over to the array makes things like the builtin-diff usage much simpler
(we now see exactly how many members the array has, and we don't get the
objects reversed from the order they were on the command line).
One of the main reasons for doing this at all is that the malloc overhead
of the simple object list was actually pretty high, and the array is just
a lot denser. So this patch brings down memory usage by git-rev-list by
just under 3% (on top of all the other memory use optimizations) on the
mozilla archive.
It does add more lines than it removes, and more importantly, it adds a
whole new infrastructure for maintaining lists of objects, but on the
other hand, the new dynamic array code is pretty obvious. The change to
builtin-diff-tree.c shows a fairly good example of why an array interface
is sometimes more natural, and just much simpler for everybody.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-20 02:42:35 +02:00
int i ;
2005-11-02 20:19:24 +01:00
struct commit * commit ;
Add "named object array" concept
We've had this notion of a "object_list" for a long time, which eventually
grew a "name" member because some users (notably git-rev-list) wanted to
name each object as it is generated.
That object_list is great for some things, but it isn't all that wonderful
for others, and the "name" member is generally not used by everybody.
This patch splits the users of the object_list array up into two: the
traditional list users, who want the list-like format, and who don't
actually use or want the name. And another class of users that really used
the list as an extensible array, and generally wanted to name the objects.
The patch is fairly straightforward, but it's also biggish. Most of it
really just cleans things up: switching the revision parsing and listing
over to the array makes things like the builtin-diff usage much simpler
(we now see exactly how many members the array has, and we don't get the
objects reversed from the order they were on the command line).
One of the main reasons for doing this at all is that the malloc overhead
of the simple object list was actually pretty high, and the array is just
a lot denser. So this patch brings down memory usage by git-rev-list by
just under 3% (on top of all the other memory use optimizations) on the
mozilla archive.
It does add more lines than it removes, and more importantly, it adds a
whole new infrastructure for maintaining lists of objects, but on the
other hand, the new dynamic array code is pretty obvious. The change to
builtin-diff-tree.c shows a fairly good example of why an array interface
is sometimes more natural, and just much simpler for everybody.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-20 02:42:35 +02:00
struct object_list * * p = & objects ;
2006-03-11 05:18:33 +01:00
int count = 0 ;
2005-11-02 20:19:24 +01:00
2006-03-08 01:13:20 +01:00
while ( ( commit = get_revision ( revs ) ) ! = NULL ) {
p = process_tree ( commit - > tree , p , NULL , " " ) ;
commit - > object . flags | = LOCAL ;
if ( ! ( commit - > object . flags & UNINTERESTING ) )
2006-03-11 05:18:33 +01:00
count + = add_send_request ( & commit - > object , lock ) ;
2006-03-08 01:13:20 +01:00
}
2005-11-02 20:19:24 +01:00
Add "named object array" concept
We've had this notion of a "object_list" for a long time, which eventually
grew a "name" member because some users (notably git-rev-list) wanted to
name each object as it is generated.
That object_list is great for some things, but it isn't all that wonderful
for others, and the "name" member is generally not used by everybody.
This patch splits the users of the object_list array up into two: the
traditional list users, who want the list-like format, and who don't
actually use or want the name. And another class of users that really used
the list as an extensible array, and generally wanted to name the objects.
The patch is fairly straightforward, but it's also biggish. Most of it
really just cleans things up: switching the revision parsing and listing
over to the array makes things like the builtin-diff usage much simpler
(we now see exactly how many members the array has, and we don't get the
objects reversed from the order they were on the command line).
One of the main reasons for doing this at all is that the malloc overhead
of the simple object list was actually pretty high, and the array is just
a lot denser. So this patch brings down memory usage by git-rev-list by
just under 3% (on top of all the other memory use optimizations) on the
mozilla archive.
It does add more lines than it removes, and more importantly, it adds a
whole new infrastructure for maintaining lists of objects, but on the
other hand, the new dynamic array code is pretty obvious. The change to
builtin-diff-tree.c shows a fairly good example of why an array interface
is sometimes more natural, and just much simpler for everybody.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-20 02:42:35 +02:00
for ( i = 0 ; i < revs - > pending . nr ; i + + ) {
struct object_array_entry * entry = revs - > pending . objects + i ;
struct object * obj = entry - > item ;
const char * name = entry - > name ;
2005-11-02 20:19:24 +01:00
2006-03-08 01:13:20 +01:00
if ( obj - > flags & ( UNINTERESTING | SEEN ) )
continue ;
2006-07-12 05:45:31 +02:00
if ( obj - > type = = OBJ_TAG ) {
2006-03-08 01:13:20 +01:00
obj - > flags | = SEEN ;
Add "named object array" concept
We've had this notion of a "object_list" for a long time, which eventually
grew a "name" member because some users (notably git-rev-list) wanted to
name each object as it is generated.
That object_list is great for some things, but it isn't all that wonderful
for others, and the "name" member is generally not used by everybody.
This patch splits the users of the object_list array up into two: the
traditional list users, who want the list-like format, and who don't
actually use or want the name. And another class of users that really used
the list as an extensible array, and generally wanted to name the objects.
The patch is fairly straightforward, but it's also biggish. Most of it
really just cleans things up: switching the revision parsing and listing
over to the array makes things like the builtin-diff usage much simpler
(we now see exactly how many members the array has, and we don't get the
objects reversed from the order they were on the command line).
One of the main reasons for doing this at all is that the malloc overhead
of the simple object list was actually pretty high, and the array is just
a lot denser. So this patch brings down memory usage by git-rev-list by
just under 3% (on top of all the other memory use optimizations) on the
mozilla archive.
It does add more lines than it removes, and more importantly, it adds a
whole new infrastructure for maintaining lists of objects, but on the
other hand, the new dynamic array code is pretty obvious. The change to
builtin-diff-tree.c shows a fairly good example of why an array interface
is sometimes more natural, and just much simpler for everybody.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-20 02:42:35 +02:00
p = add_one_object ( obj , p ) ;
2006-03-08 01:13:20 +01:00
continue ;
2005-11-02 20:19:24 +01:00
}
2006-07-12 05:45:31 +02:00
if ( obj - > type = = OBJ_TREE ) {
2006-03-08 01:13:20 +01:00
p = process_tree ( ( struct tree * ) obj , p , NULL , name ) ;
continue ;
2005-11-02 20:19:24 +01:00
}
2006-07-12 05:45:31 +02:00
if ( obj - > type = = OBJ_BLOB ) {
2006-03-08 01:13:20 +01:00
p = process_blob ( ( struct blob * ) obj , p , NULL , name ) ;
continue ;
2005-11-02 20:19:24 +01:00
}
2006-03-08 01:13:20 +01:00
die ( " unknown pending object %s (%s) " , sha1_to_hex ( obj - > sha1 ) , name ) ;
}
while ( objects ) {
if ( ! ( objects - > item - > flags & UNINTERESTING ) )
2006-03-11 05:18:33 +01:00
count + = add_send_request ( objects - > item , lock ) ;
2006-03-08 01:13:20 +01:00
objects = objects - > next ;
2005-11-02 20:19:24 +01:00
}
2006-03-11 05:18:33 +01:00
return count ;
2005-11-02 20:19:24 +01:00
}
2006-03-08 01:13:20 +01:00
static int update_remote ( unsigned char * sha1 , struct remote_lock * lock )
2005-11-02 20:19:24 +01:00
{
struct active_request_slot * slot ;
2006-03-11 05:18:01 +01:00
struct slot_results results ;
2005-11-02 20:19:24 +01:00
char * out_data ;
char * if_header ;
struct buffer out_buffer ;
struct curl_slist * dav_headers = NULL ;
int i ;
2005-11-04 23:22:31 +01:00
if_header = xmalloc ( strlen ( lock - > token ) + 25 ) ;
sprintf ( if_header , " If: (<opaquelocktoken:%s>) " , lock - > token ) ;
2005-11-02 20:19:24 +01:00
dav_headers = curl_slist_append ( dav_headers , if_header ) ;
out_buffer . size = 41 ;
out_data = xmalloc ( out_buffer . size + 1 ) ;
i = snprintf ( out_data , out_buffer . size + 1 , " %s \n " , sha1_to_hex ( sha1 ) ) ;
if ( i ! = out_buffer . size ) {
fprintf ( stderr , " Unable to initialize PUT request body \n " ) ;
return 0 ;
}
out_buffer . posn = 0 ;
out_buffer . buffer = out_data ;
slot = get_active_slot ( ) ;
2006-03-11 05:18:01 +01:00
slot - > results = & results ;
2005-11-02 20:19:24 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_INFILE , & out_buffer ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_INFILESIZE , out_buffer . size ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_READFUNCTION , fread_buffer ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_WRITEFUNCTION , fwrite_null ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_CUSTOMREQUEST , DAV_PUT ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_HTTPHEADER , dav_headers ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_UPLOAD , 1 ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_PUT , 1 ) ;
2005-11-04 23:22:35 +01:00
curl_easy_setopt ( slot - > curl , CURLOPT_URL , lock - > url ) ;
2005-11-02 20:19:24 +01:00
if ( start_active_slot ( slot ) ) {
run_active_slot ( slot ) ;
free ( out_data ) ;
free ( if_header ) ;
2006-03-11 05:18:01 +01:00
if ( results . curl_result ! = CURLE_OK ) {
2005-11-02 20:19:24 +01:00
fprintf ( stderr ,
" PUT error: curl result=%d, HTTP code=%ld \n " ,
2006-03-11 05:18:01 +01:00
results . curl_result , results . http_code ) ;
2005-11-02 20:19:24 +01:00
/* We should attempt recovery? */
return 0 ;
}
} else {
free ( out_data ) ;
free ( if_header ) ;
fprintf ( stderr , " Unable to start PUT request \n " ) ;
return 0 ;
}
return 1 ;
}
2006-03-08 01:13:20 +01:00
static struct ref * local_refs , * * local_tail ;
static struct ref * remote_refs , * * remote_tail ;
static int one_local_ref ( const char * refname , const unsigned char * sha1 )
{
struct ref * ref ;
int len = strlen ( refname ) + 1 ;
ref = xcalloc ( 1 , sizeof ( * ref ) + len ) ;
memcpy ( ref - > new_sha1 , sha1 , 20 ) ;
memcpy ( ref - > name , refname , len ) ;
* local_tail = ref ;
local_tail = & ref - > next ;
return 0 ;
}
static void one_remote_ref ( char * refname )
{
struct ref * ref ;
unsigned char remote_sha1 [ 20 ] ;
2006-03-11 05:18:18 +01:00
struct object * obj ;
2006-03-22 00:49:05 +01:00
int len = strlen ( refname ) + 1 ;
2006-03-08 01:13:20 +01:00
if ( fetch_ref ( refname , remote_sha1 ) ! = 0 ) {
fprintf ( stderr ,
" Unable to fetch ref %s from %s \n " ,
refname , remote - > url ) ;
return ;
}
2006-03-11 05:18:18 +01:00
/*
* Fetch a copy of the object if it doesn ' t exist locally - it
* may be required for updating server info later .
*/
if ( remote - > can_update_info_refs & & ! has_sha1_file ( remote_sha1 ) ) {
obj = lookup_unknown_object ( remote_sha1 ) ;
if ( obj ) {
fprintf ( stderr , " fetch %s for %s \n " ,
sha1_to_hex ( remote_sha1 ) , refname ) ;
add_fetch_request ( obj ) ;
}
}
2006-03-08 01:13:20 +01:00
ref = xcalloc ( 1 , sizeof ( * ref ) + len ) ;
memcpy ( ref - > old_sha1 , remote_sha1 , 20 ) ;
memcpy ( ref - > name , refname , len ) ;
* remote_tail = ref ;
remote_tail = & ref - > next ;
}
static void get_local_heads ( void )
{
local_tail = & local_refs ;
for_each_ref ( one_local_ref ) ;
}
static void get_dav_remote_heads ( void )
{
remote_tail = & remote_refs ;
2006-03-11 05:18:08 +01:00
remote_ls ( " refs/ " , ( PROCESS_FILES | PROCESS_DIRS | RECURSIVE ) , process_ls_ref , NULL ) ;
2006-03-08 01:13:20 +01:00
}
static int is_zero_sha1 ( const unsigned char * sha1 )
{
int i ;
for ( i = 0 ; i < 20 ; i + + ) {
if ( * sha1 + + )
return 0 ;
}
return 1 ;
}
static void unmark_and_free ( struct commit_list * list , unsigned int mark )
{
while ( list ) {
struct commit_list * temp = list ;
temp - > item - > object . flags & = ~ mark ;
list = temp - > next ;
free ( temp ) ;
}
}
static int ref_newer ( const unsigned char * new_sha1 ,
const unsigned char * old_sha1 )
{
struct object * o ;
struct commit * old , * new ;
struct commit_list * list , * used ;
int found = 0 ;
/* Both new and old must be commit-ish and new is descendant of
* old . Otherwise we require - - force .
*/
o = deref_tag ( parse_object ( old_sha1 ) , NULL , 0 ) ;
2006-07-12 05:45:31 +02:00
if ( ! o | | o - > type ! = OBJ_COMMIT )
2006-03-08 01:13:20 +01:00
return 0 ;
old = ( struct commit * ) o ;
o = deref_tag ( parse_object ( new_sha1 ) , NULL , 0 ) ;
2006-07-12 05:45:31 +02:00
if ( ! o | | o - > type ! = OBJ_COMMIT )
2006-03-08 01:13:20 +01:00
return 0 ;
new = ( struct commit * ) o ;
if ( parse_commit ( new ) < 0 )
return 0 ;
used = list = NULL ;
commit_list_insert ( new , & list ) ;
while ( list ) {
new = pop_most_recent_commit ( & list , TMP_MARK ) ;
commit_list_insert ( new , & used ) ;
if ( new = = old ) {
found = 1 ;
break ;
}
}
unmark_and_free ( list , TMP_MARK ) ;
unmark_and_free ( used , TMP_MARK ) ;
return found ;
}
static void mark_edge_parents_uninteresting ( struct commit * commit )
{
struct commit_list * parents ;
for ( parents = commit - > parents ; parents ; parents = parents - > next ) {
struct commit * parent = parents - > item ;
if ( ! ( parent - > object . flags & UNINTERESTING ) )
continue ;
mark_tree_uninteresting ( parent - > tree ) ;
}
}
static void mark_edges_uninteresting ( struct commit_list * list )
{
for ( ; list ; list = list - > next ) {
struct commit * commit = list - > item ;
if ( commit - > object . flags & UNINTERESTING ) {
mark_tree_uninteresting ( commit - > tree ) ;
continue ;
}
mark_edge_parents_uninteresting ( commit ) ;
}
}
2006-03-11 05:18:18 +01:00
static void add_remote_info_ref ( struct remote_ls_ctx * ls )
{
struct buffer * buf = ( struct buffer * ) ls - > userData ;
unsigned char remote_sha1 [ 20 ] ;
struct object * o ;
int len ;
char * ref_info ;
if ( fetch_ref ( ls - > dentry_name , remote_sha1 ) ! = 0 ) {
fprintf ( stderr ,
" Unable to fetch ref %s from %s \n " ,
ls - > dentry_name , remote - > url ) ;
aborted = 1 ;
return ;
}
o = parse_object ( remote_sha1 ) ;
if ( ! o ) {
fprintf ( stderr ,
" Unable to parse object %s for remote ref %s \n " ,
sha1_to_hex ( remote_sha1 ) , ls - > dentry_name ) ;
aborted = 1 ;
return ;
}
len = strlen ( ls - > dentry_name ) + 42 ;
ref_info = xcalloc ( len + 1 , 1 ) ;
sprintf ( ref_info , " %s %s \n " ,
sha1_to_hex ( remote_sha1 ) , ls - > dentry_name ) ;
fwrite_buffer ( ref_info , 1 , len , buf ) ;
free ( ref_info ) ;
2006-07-12 05:45:31 +02:00
if ( o - > type = = OBJ_TAG ) {
2006-03-11 05:18:18 +01:00
o = deref_tag ( o , ls - > dentry_name , 0 ) ;
if ( o ) {
len = strlen ( ls - > dentry_name ) + 45 ;
ref_info = xcalloc ( len + 1 , 1 ) ;
sprintf ( ref_info , " %s %s^{} \n " ,
sha1_to_hex ( o - > sha1 ) , ls - > dentry_name ) ;
fwrite_buffer ( ref_info , 1 , len , buf ) ;
free ( ref_info ) ;
}
}
}
static void update_remote_info_refs ( struct remote_lock * lock )
{
struct buffer buffer ;
struct active_request_slot * slot ;
struct slot_results results ;
char * if_header ;
struct curl_slist * dav_headers = NULL ;
2006-04-03 20:30:46 +02:00
buffer . buffer = xcalloc ( 1 , 4096 ) ;
2006-03-11 05:18:18 +01:00
buffer . size = 4096 ;
buffer . posn = 0 ;
remote_ls ( " refs/ " , ( PROCESS_FILES | RECURSIVE ) ,
add_remote_info_ref , & buffer ) ;
if ( ! aborted ) {
if_header = xmalloc ( strlen ( lock - > token ) + 25 ) ;
sprintf ( if_header , " If: (<opaquelocktoken:%s>) " , lock - > token ) ;
dav_headers = curl_slist_append ( dav_headers , if_header ) ;
slot = get_active_slot ( ) ;
slot - > results = & results ;
curl_easy_setopt ( slot - > curl , CURLOPT_INFILE , & buffer ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_INFILESIZE , buffer . posn ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_READFUNCTION , fread_buffer ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_WRITEFUNCTION , fwrite_null ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_CUSTOMREQUEST , DAV_PUT ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_HTTPHEADER , dav_headers ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_UPLOAD , 1 ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_PUT , 1 ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_URL , lock - > url ) ;
buffer . posn = 0 ;
if ( start_active_slot ( slot ) ) {
run_active_slot ( slot ) ;
if ( results . curl_result ! = CURLE_OK ) {
fprintf ( stderr ,
" PUT error: curl result=%d, HTTP code=%ld \n " ,
results . curl_result , results . http_code ) ;
}
}
free ( if_header ) ;
}
free ( buffer . buffer ) ;
}
static int remote_exists ( const char * path )
{
char * url = xmalloc ( strlen ( remote - > url ) + strlen ( path ) + 1 ) ;
struct active_request_slot * slot ;
struct slot_results results ;
sprintf ( url , " %s%s " , remote - > url , path ) ;
slot = get_active_slot ( ) ;
slot - > results = & results ;
curl_easy_setopt ( slot - > curl , CURLOPT_URL , url ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_NOBODY , 1 ) ;
if ( start_active_slot ( slot ) ) {
run_active_slot ( slot ) ;
if ( results . http_code = = 404 )
return 0 ;
else if ( results . curl_result = = CURLE_OK )
return 1 ;
else
fprintf ( stderr , " HEAD HTTP error %ld \n " , results . http_code ) ;
} else {
fprintf ( stderr , " Unable to start HEAD request \n " ) ;
}
return - 1 ;
}
2006-06-28 11:04:39 +02:00
static void fetch_symref ( const char * path , char * * symref , unsigned char * sha1 )
2006-03-20 19:31:06 +01:00
{
char * url ;
struct buffer buffer ;
struct active_request_slot * slot ;
struct slot_results results ;
url = xmalloc ( strlen ( remote - > url ) + strlen ( path ) + 1 ) ;
sprintf ( url , " %s%s " , remote - > url , path ) ;
buffer . size = 4096 ;
buffer . posn = 0 ;
buffer . buffer = xmalloc ( buffer . size ) ;
slot = get_active_slot ( ) ;
slot - > results = & results ;
curl_easy_setopt ( slot - > curl , CURLOPT_FILE , & buffer ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_WRITEFUNCTION , fwrite_buffer ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_HTTPHEADER , NULL ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_URL , url ) ;
if ( start_active_slot ( slot ) ) {
run_active_slot ( slot ) ;
if ( results . curl_result ! = CURLE_OK ) {
die ( " Couldn't get %s for remote symref \n %s " ,
url , curl_errorstr ) ;
}
} else {
die ( " Unable to start remote symref request " ) ;
}
free ( url ) ;
if ( * symref ! = NULL )
free ( * symref ) ;
* symref = NULL ;
memset ( sha1 , 0 , 20 ) ;
if ( buffer . posn = = 0 )
return ;
/* If it's a symref, set the refname; otherwise try for a sha1 */
if ( ! strncmp ( ( char * ) buffer . buffer , " ref: " , 5 ) ) {
2006-06-11 14:03:28 +02:00
* symref = xmalloc ( buffer . posn - 5 ) ;
2006-06-24 16:01:25 +02:00
strlcpy ( * symref , ( char * ) buffer . buffer + 5 , buffer . posn - 5 ) ;
2006-03-20 19:31:06 +01:00
} else {
get_sha1_hex ( buffer . buffer , sha1 ) ;
}
free ( buffer . buffer ) ;
}
static int verify_merge_base ( unsigned char * head_sha1 , unsigned char * branch_sha1 )
{
int pipe_fd [ 2 ] ;
pid_t merge_base_pid ;
char line [ PATH_MAX + 20 ] ;
unsigned char merge_sha1 [ 20 ] ;
int verified = 0 ;
if ( pipe ( pipe_fd ) < 0 )
die ( " Verify merge base: pipe failed " ) ;
merge_base_pid = fork ( ) ;
if ( ! merge_base_pid ) {
static const char * args [ ] = {
" merge-base " ,
" -a " ,
NULL ,
NULL ,
NULL
} ;
args [ 2 ] = strdup ( sha1_to_hex ( head_sha1 ) ) ;
args [ 3 ] = sha1_to_hex ( branch_sha1 ) ;
dup2 ( pipe_fd [ 1 ] , 1 ) ;
close ( pipe_fd [ 0 ] ) ;
close ( pipe_fd [ 1 ] ) ;
execv_git_cmd ( args ) ;
die ( " merge-base setup failed " ) ;
}
if ( merge_base_pid < 0 )
die ( " merge-base fork failed " ) ;
dup2 ( pipe_fd [ 0 ] , 0 ) ;
close ( pipe_fd [ 0 ] ) ;
close ( pipe_fd [ 1 ] ) ;
while ( fgets ( line , sizeof ( line ) , stdin ) ! = NULL ) {
if ( get_sha1_hex ( line , merge_sha1 ) )
die ( " expected sha1, got garbage: \n %s " , line ) ;
if ( ! memcmp ( branch_sha1 , merge_sha1 , 20 ) ) {
verified = 1 ;
break ;
}
}
return verified ;
}
static int delete_remote_branch ( char * pattern , int force )
{
struct ref * refs = remote_refs ;
struct ref * remote_ref = NULL ;
unsigned char head_sha1 [ 20 ] ;
char * symref = NULL ;
int match ;
int patlen = strlen ( pattern ) ;
int i ;
struct active_request_slot * slot ;
struct slot_results results ;
char * url ;
/* Find the remote branch(es) matching the specified branch name */
for ( match = 0 ; refs ; refs = refs - > next ) {
char * name = refs - > name ;
int namelen = strlen ( name ) ;
if ( namelen < patlen | |
memcmp ( name + namelen - patlen , pattern , patlen ) )
continue ;
if ( namelen ! = patlen & & name [ namelen - patlen - 1 ] ! = ' / ' )
continue ;
match + + ;
remote_ref = refs ;
}
if ( match = = 0 )
return error ( " No remote branch matches %s " , pattern ) ;
if ( match ! = 1 )
return error ( " More than one remote branch matches %s " ,
pattern ) ;
/*
* Remote HEAD must be a symref ( not exactly foolproof ; a remote
* symlink to a symref will look like a symref )
*/
fetch_symref ( " HEAD " , & symref , head_sha1 ) ;
if ( ! symref )
return error ( " Remote HEAD is not a symref " ) ;
/* Remote branch must not be the remote HEAD */
for ( i = 0 ; symref & & i < MAXDEPTH ; i + + ) {
if ( ! strcmp ( remote_ref - > name , symref ) )
return error ( " Remote branch %s is the current HEAD " ,
remote_ref - > name ) ;
fetch_symref ( symref , & symref , head_sha1 ) ;
}
/* Run extra sanity checks if delete is not forced */
if ( ! force ) {
/* Remote HEAD must resolve to a known object */
if ( symref )
return error ( " Remote HEAD symrefs too deep " ) ;
if ( is_zero_sha1 ( head_sha1 ) )
return error ( " Unable to resolve remote HEAD " ) ;
if ( ! has_sha1_file ( head_sha1 ) )
return error ( " Remote HEAD resolves to object %s \n which does not exist locally, perhaps you need to fetch? " , sha1_to_hex ( head_sha1 ) ) ;
/* Remote branch must resolve to a known object */
if ( is_zero_sha1 ( remote_ref - > old_sha1 ) )
return error ( " Unable to resolve remote branch %s " ,
remote_ref - > name ) ;
if ( ! has_sha1_file ( remote_ref - > old_sha1 ) )
return error ( " Remote branch %s resolves to object %s \n which does not exist locally, perhaps you need to fetch? " , remote_ref - > name , sha1_to_hex ( remote_ref - > old_sha1 ) ) ;
/* Remote branch must be an ancestor of remote HEAD */
if ( ! verify_merge_base ( head_sha1 , remote_ref - > old_sha1 ) ) {
return error ( " The branch '%s' is not a strict subset of your current HEAD. \n If you are sure you want to delete it, run: \n \t 'git http-push -D %s %s' " , remote_ref - > name , remote - > url , pattern ) ;
}
}
/* Send delete request */
fprintf ( stderr , " Removing remote branch '%s' \n " , remote_ref - > name ) ;
url = xmalloc ( strlen ( remote - > url ) + strlen ( remote_ref - > name ) + 1 ) ;
sprintf ( url , " %s%s " , remote - > url , remote_ref - > name ) ;
slot = get_active_slot ( ) ;
slot - > results = & results ;
curl_easy_setopt ( slot - > curl , CURLOPT_HTTPGET , 1 ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_WRITEFUNCTION , fwrite_null ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_URL , url ) ;
curl_easy_setopt ( slot - > curl , CURLOPT_CUSTOMREQUEST , DAV_DELETE ) ;
if ( start_active_slot ( slot ) ) {
run_active_slot ( slot ) ;
free ( url ) ;
if ( results . curl_result ! = CURLE_OK )
return error ( " DELETE request failed (%d/%ld) \n " ,
results . curl_result , results . http_code ) ;
} else {
free ( url ) ;
return error ( " Unable to start DELETE request " ) ;
}
return 0 ;
}
2005-11-02 20:19:24 +01:00
int main ( int argc , char * * argv )
{
struct transfer_request * request ;
struct transfer_request * next_request ;
int nr_refspec = 0 ;
char * * refspec = NULL ;
2006-03-11 05:18:12 +01:00
struct remote_lock * ref_lock = NULL ;
2006-03-11 05:18:18 +01:00
struct remote_lock * info_ref_lock = NULL ;
2006-03-08 01:13:20 +01:00
struct rev_info revs ;
2006-03-20 19:31:06 +01:00
int delete_branch = 0 ;
int force_delete = 0 ;
2006-03-11 05:18:33 +01:00
int objects_to_send ;
2005-11-02 20:19:24 +01:00
int rc = 0 ;
int i ;
2006-03-22 00:49:05 +01:00
int new_refs ;
struct ref * ref ;
2005-11-02 20:19:24 +01:00
2005-11-26 09:47:59 +01:00
setup_git_directory ( ) ;
2005-11-02 20:19:24 +01:00
setup_ident ( ) ;
2006-03-11 05:18:12 +01:00
remote = xcalloc ( sizeof ( * remote ) , 1 ) ;
2005-11-02 20:19:24 +01:00
argv + + ;
for ( i = 1 ; i < argc ; i + + , argv + + ) {
char * arg = * argv ;
if ( * arg = = ' - ' ) {
2006-03-08 01:13:20 +01:00
if ( ! strcmp ( arg , " --all " ) ) {
2005-11-02 20:19:24 +01:00
push_all = 1 ;
continue ;
}
if ( ! strcmp ( arg , " --force " ) ) {
force_all = 1 ;
continue ;
}
if ( ! strcmp ( arg , " --verbose " ) ) {
push_verbosely = 1 ;
continue ;
}
2006-03-20 19:31:06 +01:00
if ( ! strcmp ( arg , " -d " ) ) {
delete_branch = 1 ;
continue ;
}
if ( ! strcmp ( arg , " -D " ) ) {
delete_branch = 1 ;
force_delete = 1 ;
continue ;
}
2005-11-02 20:19:24 +01:00
}
if ( ! remote - > url ) {
2006-03-08 01:13:20 +01:00
char * path = strstr ( arg , " // " ) ;
2006-03-22 00:49:05 +01:00
remote - > url = arg ;
2006-03-08 01:13:20 +01:00
if ( path ) {
2006-04-11 18:37:58 +02:00
path = strchr ( path + 2 , ' / ' ) ;
2006-03-08 01:13:20 +01:00
if ( path )
remote - > path_len = strlen ( path ) ;
}
2005-11-02 20:19:24 +01:00
continue ;
}
refspec = argv ;
nr_refspec = argc - i ;
break ;
}
2005-11-29 18:33:36 +01:00
if ( ! remote - > url )
usage ( http_push_usage ) ;
2006-03-20 19:31:06 +01:00
if ( delete_branch & & nr_refspec ! = 1 )
die ( " You must specify only one branch name when deleting a remote branch " ) ;
2006-03-08 01:13:20 +01:00
memset ( remote_dir_exists , - 1 , 256 ) ;
2005-11-07 20:39:37 +01:00
2005-11-18 20:02:58 +01:00
http_init ( ) ;
2005-11-02 20:19:24 +01:00
no_pragma_header = curl_slist_append ( no_pragma_header , " Pragma: " ) ;
default_headers = curl_slist_append ( default_headers , " Range: " ) ;
default_headers = curl_slist_append ( default_headers , " Destination: " ) ;
default_headers = curl_slist_append ( default_headers , " If: " ) ;
default_headers = curl_slist_append ( default_headers ,
" Pragma: no-cache " ) ;
/* Verify DAV compliance/lock support */
2005-11-18 20:03:18 +01:00
if ( ! locking_available ( ) ) {
2005-11-02 20:19:24 +01:00
fprintf ( stderr , " Error: no DAV locking support on remote repo %s \n " , remote - > url ) ;
rc = 1 ;
goto cleanup ;
}
2006-03-11 05:18:18 +01:00
/* Check whether the remote has server info files */
remote - > can_update_info_refs = 0 ;
remote - > has_info_refs = remote_exists ( " info/refs " ) ;
remote - > has_info_packs = remote_exists ( " objects/info/packs " ) ;
if ( remote - > has_info_refs ) {
info_ref_lock = lock_remote ( " info/refs " , LOCK_TIME ) ;
if ( info_ref_lock )
remote - > can_update_info_refs = 1 ;
}
if ( remote - > has_info_packs )
fetch_indices ( ) ;
2006-03-08 01:13:20 +01:00
/* Get a list of all local and remote heads to validate refspecs */
get_local_heads ( ) ;
fprintf ( stderr , " Fetching remote heads... \n " ) ;
get_dav_remote_heads ( ) ;
2006-03-20 19:31:06 +01:00
/* Remove a remote branch if -d or -D was specified */
if ( delete_branch ) {
if ( delete_remote_branch ( refspec [ 0 ] , force_delete ) = = - 1 )
fprintf ( stderr , " Unable to delete remote branch %s \n " ,
refspec [ 0 ] ) ;
goto cleanup ;
}
2006-03-08 01:13:20 +01:00
/* match them up */
if ( ! remote_tail )
remote_tail = & remote_refs ;
if ( match_refs ( local_refs , remote_refs , & remote_tail ,
nr_refspec , refspec , push_all ) )
return - 1 ;
if ( ! remote_refs ) {
fprintf ( stderr , " No refs in common and none specified; doing nothing. \n " ) ;
return 0 ;
}
2006-03-22 00:49:05 +01:00
new_refs = 0 ;
2006-03-08 01:13:20 +01:00
for ( ref = remote_refs ; ref ; ref = ref - > next ) {
char old_hex [ 60 ] , * new_hex ;
2006-03-22 00:49:05 +01:00
const char * commit_argv [ 4 ] ;
int commit_argc ;
char * new_sha1_hex , * old_sha1_hex ;
2006-03-08 01:13:20 +01:00
if ( ! ref - > peer_ref )
continue ;
if ( ! memcmp ( ref - > old_sha1 , ref - > peer_ref - > new_sha1 , 20 ) ) {
if ( push_verbosely | | 1 )
fprintf ( stderr , " '%s': up-to-date \n " , ref - > name ) ;
continue ;
}
if ( ! force_all & &
! is_zero_sha1 ( ref - > old_sha1 ) & &
! ref - > force ) {
if ( ! has_sha1_file ( ref - > old_sha1 ) | |
! ref_newer ( ref - > peer_ref - > new_sha1 ,
ref - > old_sha1 ) ) {
/* We do not have the remote ref, or
* we know that the remote ref is not
* an ancestor of what we are trying to
* push . Either way this can be losing
* commits at the remote end and likely
* we were not up to date to begin with .
*/
error ( " remote '%s' is not a strict "
" subset of local ref '%s'. "
" maybe you are not up-to-date and "
" need to pull first? " ,
ref - > name ,
ref - > peer_ref - > name ) ;
2006-03-11 05:18:33 +01:00
rc = - 2 ;
2006-03-08 01:13:20 +01:00
continue ;
}
2005-11-02 20:19:24 +01:00
}
2006-03-08 01:13:20 +01:00
memcpy ( ref - > new_sha1 , ref - > peer_ref - > new_sha1 , 20 ) ;
if ( is_zero_sha1 ( ref - > new_sha1 ) ) {
error ( " cannot happen anymore " ) ;
2006-03-11 05:18:33 +01:00
rc = - 3 ;
2006-03-08 01:13:20 +01:00
continue ;
2005-11-02 20:19:24 +01:00
}
2006-03-08 01:13:20 +01:00
new_refs + + ;
strcpy ( old_hex , sha1_to_hex ( ref - > old_sha1 ) ) ;
new_hex = sha1_to_hex ( ref - > new_sha1 ) ;
fprintf ( stderr , " updating '%s' " , ref - > name ) ;
if ( strcmp ( ref - > name , ref - > peer_ref - > name ) )
fprintf ( stderr , " using '%s' " , ref - > peer_ref - > name ) ;
fprintf ( stderr , " \n from %s \n to %s \n " , old_hex , new_hex ) ;
2005-11-02 20:19:24 +01:00
/* Lock remote branch ref */
2006-03-08 01:13:20 +01:00
ref_lock = lock_remote ( ref - > name , LOCK_TIME ) ;
if ( ref_lock = = NULL ) {
2005-11-02 20:19:24 +01:00
fprintf ( stderr , " Unable to lock remote branch %s \n " ,
2006-03-08 01:13:20 +01:00
ref - > name ) ;
2005-11-02 20:19:24 +01:00
rc = 1 ;
continue ;
}
2006-03-08 01:13:20 +01:00
/* Set up revision info for this refspec */
2006-03-22 00:49:05 +01:00
commit_argc = 3 ;
new_sha1_hex = strdup ( sha1_to_hex ( ref - > new_sha1 ) ) ;
old_sha1_hex = NULL ;
2006-03-11 05:17:55 +01:00
commit_argv [ 1 ] = " --objects " ;
commit_argv [ 2 ] = new_sha1_hex ;
2006-03-08 01:13:20 +01:00
if ( ! push_all & & ! is_zero_sha1 ( ref - > old_sha1 ) ) {
old_sha1_hex = xmalloc ( 42 ) ;
sprintf ( old_sha1_hex , " ^%s " ,
sha1_to_hex ( ref - > old_sha1 ) ) ;
2006-03-11 05:17:55 +01:00
commit_argv [ 3 ] = old_sha1_hex ;
2006-03-08 01:13:20 +01:00
commit_argc + + ;
2005-11-02 20:19:24 +01:00
}
2006-04-16 08:46:36 +02:00
init_revisions ( & revs ) ;
2006-03-08 01:13:20 +01:00
setup_revisions ( commit_argc , commit_argv , & revs , NULL ) ;
free ( new_sha1_hex ) ;
if ( old_sha1_hex ) {
free ( old_sha1_hex ) ;
commit_argv [ 1 ] = NULL ;
2005-11-02 20:19:24 +01:00
}
2006-03-08 01:13:20 +01:00
/* Generate a list of objects that need to be pushed */
2005-11-02 20:19:24 +01:00
pushing = 0 ;
2006-03-08 01:13:20 +01:00
prepare_revision_walk ( & revs ) ;
mark_edges_uninteresting ( revs . commits ) ;
2006-03-11 05:18:33 +01:00
objects_to_send = get_delta ( & revs , ref_lock ) ;
2005-11-18 20:02:58 +01:00
finish_all_active_slots ( ) ;
2005-11-02 20:19:24 +01:00
/* Push missing objects to remote, this would be a
convenient time to pack them first if appropriate . */
pushing = 1 ;
2006-03-11 05:18:33 +01:00
if ( objects_to_send )
fprintf ( stderr , " sending %d objects \n " ,
objects_to_send ) ;
2006-06-06 18:41:32 +02:00
# ifdef USE_CURL_MULTI
2005-11-18 20:02:58 +01:00
fill_active_slots ( ) ;
2006-06-06 18:41:32 +02:00
# endif
2005-11-18 20:02:58 +01:00
finish_all_active_slots ( ) ;
2005-11-02 20:19:24 +01:00
/* Update the remote branch if all went well */
2006-03-08 01:13:20 +01:00
if ( aborted | | ! update_remote ( ref - > new_sha1 , ref_lock ) ) {
rc = 1 ;
goto unlock ;
2005-11-02 20:19:24 +01:00
}
unlock :
2006-03-08 01:13:20 +01:00
if ( ! rc )
fprintf ( stderr , " done \n " ) ;
unlock_remote ( ref_lock ) ;
2006-03-11 05:18:12 +01:00
check_locks ( ) ;
2005-11-02 20:19:24 +01:00
}
2006-03-11 05:18:18 +01:00
/* Update remote server info if appropriate */
if ( remote - > has_info_refs & & new_refs ) {
if ( info_ref_lock & & remote - > can_update_info_refs ) {
fprintf ( stderr , " Updating remote server info \n " ) ;
update_remote_info_refs ( info_ref_lock ) ;
} else {
fprintf ( stderr , " Unable to update server info \n " ) ;
}
}
if ( info_ref_lock )
unlock_remote ( info_ref_lock ) ;
2005-11-02 20:19:24 +01:00
cleanup :
free ( remote ) ;
curl_slist_free_all ( no_pragma_header ) ;
curl_slist_free_all ( default_headers ) ;
2005-11-18 20:02:58 +01:00
http_cleanup ( ) ;
2005-11-02 20:19:24 +01:00
request = request_queue_head ;
while ( request ! = NULL ) {
next_request = request - > next ;
release_request ( request ) ;
request = next_request ;
}
return rc ;
}
