dav: comparison libidav/resource.c

-:de23f8881e9f
+:1fb26aca5093
 int dav_store(DavResource *res) {
 DavSession *sn = res->session;
 DavResourceData *data = res->data;
 util_set_url(sn, dav_resource_get_href(res));
+DavLock *lock = dav_get_lock(sn, res->path);
+char *locktoken = lock ? lock->token : NULL;
 // store content
 if(data->content) {
 int encryption = DAV_ENCRYPT_CONTENT(sn) && sn->key;
 CURLcode ret;
 if(encryption) {
 enc = aes_encrypter_new(
 sn->key,
 buf,
 (dav_read_func)ucx_buffer_read);
 }
 // put resource
 ret = do_put_request(
 sn->handle,
+locktoken,
 enc,
 (dav_read_func)aes_read,
 0);
 // get sha256 hash
 resource_add_property(res, DAV_NS, "crypto-hash", enc_hash);
 free(enc_hash);
 } else {
 ret = do_put_request(
 sn->handle,
+locktoken,
 data->content,
 data->read,
 data->length);
 }
 if(data->set || data->remove) {
 UcxBuffer *request = create_proppatch_request(data);
 UcxBuffer *response = ucx_buffer_new(NULL, 1024, UCX_BUFFER_AUTOEXTEND);
 //printf("request:\n%.*s\n\n", request->pos, request->space);
-CURLcode ret = do_proppatch_request(sn->handle, request, response);
+CURLcode ret = do_proppatch_request(sn->handle, locktoken, request, response);
 long status = 0;
 curl_easy_getinfo (sn->handle, CURLINFO_RESPONSE_CODE, &status);
 if(ret == CURLE_OK && status == 207) {
 //printf("%s\n", response->space);
 // TODO: parse response
 int dav_delete(DavResource *res) {
 CURL *handle = res->session->handle;
 util_set_url(res->session, dav_resource_get_href(res));
+DavLock *lock = dav_get_lock(res->session, res->path);
+char *locktoken = lock ? lock->token : NULL;
 UcxBuffer *response = ucx_buffer_new(NULL, 4096, UCX_BUFFER_AUTOEXTEND);
-CURLcode ret = do_delete_request(handle, response);
+CURLcode ret = do_delete_request(handle, locktoken, response);
 long status = 0;
 curl_easy_getinfo (handle, CURLINFO_RESPONSE_CODE, &status);
 if(ret == CURLE_OK && (status >= 200 && status < 300)) {
 res->session->error = DAV_OK;
 }
 static int create_ancestors(DavSession *sn, char *href, char *path) {
 CURL *handle = sn->handle;
 CURLcode code;
+DavLock *lock = dav_get_lock(sn, path);
+char *locktoken = lock ? lock->token : NULL;
 long status = 0;
 int ret = 0;
 if(strlen(path) <= 1) {
 return 0;
 char *p = util_parent_path(path);
 char *h = util_parent_path(href);
 for(int i=0;i<2;i++) {
 util_set_url(sn, h);
-code = do_mkcol_request(handle);
+code = do_mkcol_request(handle, locktoken);
 curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, &status);
 if(status == 201) {
 // resource successfully created
 char *name = util_resource_name(p);
 int len = strlen(name);
 static int create_resource(DavResource *res, int *status) {
 DavSession *sn = res->session;
 CURL *handle = sn->handle;
 util_set_url(sn, dav_resource_get_href(res));
+DavLock *lock = dav_get_lock(res->session, res->path);
+char *locktoken = lock ? lock->token : NULL;
 CURLcode code;
 if(res->iscollection) {
-code = do_mkcol_request(handle);
+code = do_mkcol_request(handle, locktoken);
 } else {
-code = do_put_request(handle, "", NULL, 0);
+code = do_put_request(handle, locktoken, "", NULL, 0);
 }
 long s = 0;
 curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, &s);
 *status = s;
 if(code == CURLE_OK && (s >= 200 && s < 300)) {
 int dav_moveto(DavResource *res, char *url, DavBool override) {
 return dav_cp_mv_url(res, url, false, override);
 }
-char* dav_lock(DavResource *res) {
+int dav_lock(DavResource *res) {
 DavSession *sn = res->session;
 CURL *handle = sn->handle;
 util_set_url(sn, dav_resource_get_href(res));
 UcxBuffer *request = create_lock_request();
 curl_easy_getinfo (handle, CURLINFO_RESPONSE_CODE, &status);
 if(ret == CURLE_OK && (status >= 200 && status < 300)) {
 LockDiscovery lock;
 if(parse_lock_response(sn, response, &lock)) {
 sn->error = DAV_ERROR;
-return NULL;
+return -1;
 }
+DavLock *l = dav_create_lock(sn, lock.locktoken, lock.timeout);
+free(lock.locktoken);
 free(lock.timeout);
-return lock.locktoken;
+int r = 0;
+if(res->iscollection) {
+r = dav_add_collection_lock(sn, res->path, l);
+} else {
+r = dav_add_resource_lock(sn, res->path, l);
+}
+if(r == 0) {
+return 0;
+} else {
+(void)dav_unlock(res);
+sn->error = DAV_ERROR;
+dav_destroy_lock(sn, l);
+return -1;
+}
 } else {
 dav_session_set_error(sn, ret, status);
-return NULL;
+return -1;
 }
 }
-int dav_unlock(DavResource *res, char *locktoken) {
+int dav_unlock(DavResource *res) {
 DavSession *sn = res->session;
 CURL *handle = sn->handle;
 util_set_url(sn, dav_resource_get_href(res));
-CURLcode ret = do_unlock_request(handle, locktoken);
+DavLock *lock = dav_get_lock(res->session, res->path);
+if(!lock) {
+sn->error = DAV_ERROR;
+return -1;
+}
+CURLcode ret = do_unlock_request(handle, lock->token);
 long status = 0;
 curl_easy_getinfo (handle, CURLINFO_RESPONSE_CODE, &status);
 if(ret == CURLE_OK && (status >= 200 && status < 300)) {
+dav_remove_lock(sn, res->path, lock);
 return 0;
 } else {
 dav_session_set_error(sn, ret, status);
 return 1;
 }
 UcxBuffer *request = create_crypto_proppatch_request(sn, sn->key, name, hash);
 UcxBuffer *response = ucx_buffer_new(NULL, 1024, UCX_BUFFER_AUTOEXTEND);
 util_set_url(sn, href);
-CURLcode ret = do_proppatch_request(sn->handle, request, response);
+// TODO: lock
+CURLcode ret = do_proppatch_request(sn->handle, NULL, request, response);
 ucx_buffer_free(request);
 long status = 0;
 curl_easy_getinfo (sn->handle, CURLINFO_RESPONSE_CODE, &status);
 if(ret == CURLE_OK && status == 207) {
 // TODO: parse response

Mercurial > hg > dav / file comparison

comparison: libidav/resource.c

libidav/resource.c