static struct curl_slist *no_pragma_header;
static struct curl_slist *default_headers;
static char curl_errorstr[CURL_ERROR_SIZE];
-static char *lock_token = NULL;
static int push_verbosely = 0;
static int push_all = 0;
unsigned char sha1[20];
char *url;
char *dest;
- char *lock_token;
+ struct active_lock *lock;
struct curl_slist *headers;
struct buffer buffer;
char filename[PATH_MAX];
static long curl_low_speed_limit = -1;
static long curl_low_speed_time = -1;
+struct active_lock
+{
+ int ctx_activelock;
+ int ctx_owner;
+ int ctx_owner_href;
+ int ctx_timeout;
+ int ctx_locktoken;
+ int ctx_locktoken_href;
+ char *owner;
+ time_t start_time;
+ long timeout;
+ char *token;
+};
+
struct lockprop
{
int supported_lock;
if (request->url != NULL)
free(request->url);
request->url = xmalloc(strlen(remote->url) +
- strlen(request->lock_token) + 51);
+ strlen(request->lock->token) + 51);
strcpy(request->url, remote->url);
posn = request->url + strlen(remote->url);
strcpy(posn, "objects/");
sprintf(request->dest, "Destination: %s", request->url);
posn += 38;
*(posn++) = '.';
- strcpy(posn, request->lock_token);
+ strcpy(posn, request->lock->token);
slot = get_active_slot();
curl_easy_setopt(slot->curl, CURLOPT_INFILE, &request->buffer);
}
}
-void add_request(unsigned char *sha1, char *lock_token)
+void add_request(unsigned char *sha1, struct active_lock *lock)
{
struct transfer_request *request = request_queue_head;
struct packed_git *target;
request = xmalloc(sizeof(*request));
memcpy(request->sha1, sha1, 20);
request->url = NULL;
- request->lock_token = lock_token;
+ request->lock = lock;
request->headers = NULL;
request->state = NEED_CHECK;
request->next = request_queue_head;
}
static void
+start_activelock_element(void *userData, const char *name, const char **atts)
+{
+ struct active_lock *lock = (struct active_lock *)userData;
+
+ if (lock->ctx_activelock && !strcmp(name, "D:timeout"))
+ lock->ctx_timeout = 1;
+ else if (lock->ctx_owner && strstr(name, "href"))
+ lock->ctx_owner_href = 1;
+ else if (lock->ctx_activelock && strstr(name, "owner"))
+ lock->ctx_owner = 1;
+ else if (lock->ctx_locktoken && !strcmp(name, "D:href"))
+ lock->ctx_locktoken_href = 1;
+ else if (lock->ctx_activelock && !strcmp(name, "D:locktoken"))
+ lock->ctx_locktoken = 1;
+ else if (!strcmp(name, "D:activelock"))
+ lock->ctx_activelock = 1;
+}
+
+static void
+end_activelock_element(void *userData, const char *name)
+{
+ struct active_lock *lock = (struct active_lock *)userData;
+
+ if (lock->ctx_timeout && !strcmp(name, "D:timeout")) {
+ lock->ctx_timeout = 0;
+ } else if (lock->ctx_owner_href && strstr(name, "href")) {
+ lock->ctx_owner_href = 0;
+ } else if (lock->ctx_owner && strstr(name, "owner")) {
+ lock->ctx_owner = 0;
+ } else if (lock->ctx_locktoken_href && !strcmp(name, "D:href")) {
+ lock->ctx_locktoken_href = 0;
+ } else if (lock->ctx_locktoken && !strcmp(name, "D:locktoken")) {
+ lock->ctx_locktoken = 0;
+ } else if (lock->ctx_activelock && !strcmp(name, "D:activelock")) {
+ lock->ctx_activelock = 0;
+ }
+}
+
+static void
+activelock_cdata(void *userData, const XML_Char *s, int len)
+{
+ struct active_lock *lock = (struct active_lock *)userData;
+ char *this = malloc(len+1);
+ strncpy(this, s, len);
+
+ if (lock->ctx_owner_href) {
+ lock->owner = malloc(len+1);
+ strcpy(lock->owner, this);
+ } else if (lock->ctx_locktoken_href) {
+ if (!strncmp(this, "opaquelocktoken:", 16)) {
+ lock->token = malloc(len-15);
+ strcpy(lock->token, this+16);
+ }
+ } else if (lock->ctx_timeout) {
+ if (!strncmp(this, "Second-", 7))
+ lock->timeout = strtol(this+7, NULL, 10);
+ }
+
+ free(this);
+}
+
+static void
start_lockprop_element(void *userData, const char *name, const char **atts)
{
struct lockprop *prop = (struct lockprop *)userData;
}
}
-size_t process_lock_header( void *ptr, size_t size, size_t nmemb, void *stream)
-{
- size_t header_size = size*nmemb;
- char *start;
- char *end;
-
- if (!strncmp(ptr, "Lock-Token: <opaquelocktoken:", 29)) {
- start = ptr + 29;
- for (end = ptr + header_size;
- *(end - 1) == '\r' || *(end - 1) == '\n' || *(end - 1) == '>';
- end--) {}
- if (end > start) {
- lock_token = xmalloc(end - start + 1);
- memcpy(lock_token, start, end - start);
- lock_token[end - start] = 0;
- }
- }
-
- return header_size;
-}
-
-char *lock_remote(char *file, int timeout)
+struct active_lock *lock_remote(char *file, int timeout)
{
struct active_request_slot *slot;
struct buffer out_buffer;
+ struct buffer in_buffer;
char *out_data;
+ char *in_data;
char *url;
char *ep;
char timeout_header[25];
+ struct active_lock *new_lock;
+ XML_Parser parser = XML_ParserCreate(NULL);
+ enum XML_Status result;
struct curl_slist *dav_headers = NULL;
- if (lock_token != NULL)
- free(lock_token);
-
url = xmalloc(strlen(remote->url) + strlen(file) + 1);
sprintf(url, "%s%s", remote->url, file);
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;
+
+ new_lock = xmalloc(sizeof(*new_lock));
+ new_lock->owner = NULL;
+ new_lock->token = NULL;
+ new_lock->timeout = -1;
+
sprintf(timeout_header, "Timeout: Second-%d", timeout);
dav_headers = curl_slist_append(dav_headers, timeout_header);
dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
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_HEADERFUNCTION,
- process_lock_header);
+ curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
+ curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION,
+ fwrite_buffer_dynamic);
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);
run_active_slot(slot);
if (slot->curl_result != CURLE_OK) {
fprintf(stderr, "Got HTTP error %ld\n", slot->http_code);
+ free(new_lock);
free(url);
free(out_data);
+ free(in_data);
return NULL;
}
} else {
+ free(new_lock);
free(url);
free(out_data);
+ free(in_data);
fprintf(stderr, "Unable to start request\n");
return NULL;
}
free(url);
free(out_data);
- return strdup(lock_token);
+ XML_SetUserData(parser, new_lock);
+ XML_SetElementHandler(parser, start_activelock_element,
+ end_activelock_element);
+ XML_SetCharacterDataHandler(parser, activelock_cdata);
+ result = XML_Parse(parser, in_buffer.buffer, in_buffer.posn, 1);
+ free(in_data);
+ if (result != XML_STATUS_OK) {
+ fprintf(stderr, "%s", XML_ErrorString(
+ XML_GetErrorCode(parser)));
+ free(new_lock);
+ return NULL;
+ }
+
+ if (new_lock->token == NULL || new_lock->timeout <= 0) {
+ if (new_lock->token != NULL)
+ free(new_lock->token);
+ if (new_lock->owner != NULL)
+ free(new_lock->owner);
+ free(new_lock);
+ return NULL;
+ }
+
+ new_lock->start_time = time(NULL);
+ return new_lock;
}
-int unlock_remote(char *file, char *lock_token)
+int unlock_remote(char *file, struct active_lock *lock)
{
struct active_request_slot *slot;
char *url;
struct curl_slist *dav_headers = NULL;
int rc = 0;
- if (lock_token == NULL) {
- fprintf(stderr, "Unable to unlock, no lock token");
- return 0;
- }
-
- lock_token_header = xmalloc(strlen(lock_token) + 31);
+ lock_token_header = xmalloc(strlen(lock->token) + 31);
sprintf(lock_token_header, "Lock-Token: <opaquelocktoken:%s>",
- lock_token);
+ lock->token);
url = xmalloc(strlen(remote->url) + strlen(file) + 1);
sprintf(url, "%s%s", remote->url, file);
dav_headers = curl_slist_append(dav_headers, lock_token_header);
return 0;
}
-void get_delta(unsigned char *sha1, struct object *obj, char *lock_token)
+void get_delta(unsigned char *sha1, struct object *obj,
+ struct active_lock *lock)
{
struct commit *commit;
struct commit_list *parents;
if (obj->type == commit_type) {
if (push_verbosely)
fprintf(stderr, "walk %s\n", sha1_to_hex(obj->sha1));
- add_request(obj->sha1, lock_token);
+ add_request(obj->sha1, lock);
commit = (struct commit *)obj;
if (parse_commit(commit)) {
fprintf(stderr, "Error parsing commit %s\n",
if (sha1 == NULL ||
memcmp(sha1, parents->item->object.sha1, 20))
get_delta(sha1, &parents->item->object,
- lock_token);
- get_delta(sha1, &commit->tree->object, lock_token);
+ lock);
+ get_delta(sha1, &commit->tree->object, lock);
} else if (obj->type == tree_type) {
if (push_verbosely)
fprintf(stderr, "walk %s\n", sha1_to_hex(obj->sha1));
- add_request(obj->sha1, lock_token);
+ add_request(obj->sha1, lock);
tree = (struct tree *)obj;
if (parse_tree(tree)) {
fprintf(stderr, "Error parsing tree %s\n",
tree->entries = NULL;
while (entry) {
struct tree_entry_list *next = entry->next;
- get_delta(sha1, entry->item.any, lock_token);
+ get_delta(sha1, entry->item.any, lock);
free(entry->name);
free(entry);
entry = next;
}
} else if (obj->type == blob_type || obj->type == tag_type) {
- add_request(obj->sha1, lock_token);
+ add_request(obj->sha1, lock);
}
}
-int update_remote(char *remote_path, unsigned char *sha1, char *lock_token)
+int update_remote(char *remote_path, unsigned char *sha1,
+ struct active_lock *lock)
{
struct active_request_slot *slot;
char *url;
url = xmalloc(strlen(remote->url) + strlen(remote_path) + 1);
sprintf(url, "%s%s", remote->url, remote_path);
- if_header = xmalloc(strlen(lock_token) + 25);
- sprintf(if_header, "If: (<opaquelocktoken:%s>)", lock_token);
+ if_header = xmalloc(strlen(lock->token) + 25);
+ sprintf(if_header, "If: (<opaquelocktoken:%s>)", lock->token);
dav_headers = curl_slist_append(dav_headers, if_header);
out_buffer.size = 41;
struct object *local_object = NULL;
char *remote_ref = NULL;
unsigned char remote_sha1[20];
- char *remote_lock = NULL;
+ struct active_lock *remote_lock;
char *remote_path = NULL;
char *low_speed_limit;
char *low_speed_time;
unlock:
unlock_remote(remote_path, remote_lock);
free(remote_path);
+ if (remote_lock->owner != NULL)
+ free(remote_lock->owner);
+ free(remote_lock->token);
free(remote_lock);
}
projects / git.git / commitdiff