static int move_cleanup(void) { ne_delete(i_session, mdest); ne_delete(i_session, mdest2); ne_delete(i_session, mnoncoll); return OK; }
/* check that locks don't follow copies. */ static int copy(void) { char *dest; int count = 0; PRECOND(gotlock); dest = ne_concat(res, "-copydest", NULL); ne_delete(i_session2, dest); ONNREQ2("could not COPY locked resource", ne_copy(i_session2, 1, NE_DEPTH_ZERO, res, dest)); ONNREQ2("LOCK discovery failed", ne_lock_discover(i_session2, dest, count_discover, &count)); ONV(count != 0, ("found %d locks on copied resource", count)); ONNREQ2("could not delete copy of locked resource", ne_delete(i_session2, dest)); free(dest); return OK; }
static int copy_cleanup(void) { ne_delete(i_session, src); ne_delete(i_session, dest); ne_delete(i_session, ncoll); ne_delete(i_session, coll); return OK; }
int finish(void) { ne_delete(i_session, i_path); ne_session_destroy(i_session); printf("\n\n"); return OK; }
static int owner_modify(void) { char *tmp; ne_propname pname = { "http://webdav.org/neon/litmus/", "random" }; ne_proppatch_operation pops[] = { { NULL, ne_propset, "foobar" }, { NULL } }; PRECOND(gotlock); ONV(ne_put(i_session, res, i_foo_fd), ("PUT on locked resource failed: %s", ne_get_error(i_session))); tmp = ne_concat(i_path, "whocares", NULL); ONN("COPY of locked resource", ne_copy(i_session, 1, NE_DEPTH_ZERO, res, tmp) == NE_ERROR); if (STATUS(201)) t_warning("COPY failed with %d not 201", GETSTATUS); ONN("DELETE of locked resource by owner", ne_delete(i_session, tmp) == NE_ERROR); if (STATUS(204)) t_warning("DELETE of %s failed with %d not 200", tmp, GETSTATUS); free(tmp); ONN("PROPPATCH of locked resource", ne_proppatch(i_session, res, pops) == NE_ERROR); if (STATUS(207)) t_warning("PROPPATCH failed with %d", GETSTATUS); return OK; }
static int copy_shallow(void) { char *csrc, *cdest, *res; csrc = ne_concat(i_path, "ccsrc/", NULL); cdest = ne_concat(i_path, "ccdest/", NULL); /* Set up the ccsrc collection with one member */ ONMREQ("MKCOL", csrc, ne_mkcol(i_session, csrc)); CALL(upload_foo("ccsrc/foo")); /* Clean up to make some fresh copies. */ ne_delete(i_session, cdest); /* Now copy with Depth 0 */ ONV(ne_copy(i_session, 0, NE_DEPTH_ZERO, csrc, cdest), ("collection COPY `%s' to `%s': %s", csrc, cdest, ne_get_error(i_session))); /* Remove the source, to be paranoid. */ if (ne_delete(i_session, csrc)) { t_warning("Could not delete csrc"); } /* Now make sure the child resource hasn't been copied along with * the collection. */ res = ne_concat(i_path, "foo", NULL); ne_delete(i_session, res); ONV(STATUS(404), ("DELETE on `%s' should fail with 404: got %d", res, GETSTATUS)); ne_free(res); if (ne_delete(i_session, cdest)) { t_warning("Could not clean up cdest"); } return OK; }
static int move(void) { char *src2; src = ne_concat(i_path, "move", NULL); src2 = ne_concat(i_path, "move2", NULL); dest = ne_concat(i_path, "movedest", NULL); coll = ne_concat(i_path, "movecoll/", NULL); ncoll = ne_concat(i_path, "movecoll", NULL); /* Upload it twice. */ CALL(upload_foo("move")); CALL(upload_foo("move2")); ONMREQ("MKCOL", coll, ne_mkcol(i_session, coll)); /* Now move it */ ONM2REQ("MOVE", src, dest, ne_move(i_session, 0, src, dest)); if (STATUS(201)) { t_warning("MOVE to new resource didn't give 201"); } /* Try a move with Overwrite: F to check that fails. */ ONM2REQ("MOVE on existing resource with Overwrite: F succeeded", src2, dest, ne_move(i_session, 0, src2, dest) != NE_ERROR); if (STATUS(412)) { t_warning("MOVE-on-existing should fail with 412"); } ONM2REQ("MOVE onto existing resource with Overwrite: T", src2, dest, ne_move(i_session, 1, src2, dest)); ONM2REQ("MOVE overwrites collection", coll, dest, ne_move(i_session, 1, dest, coll)); if (STATUS(204)) { t_warning("MOVE to existing collection resource didn't give 204"); } if (ne_delete(i_session, ncoll)) { t_warning("Could not clean up `%s'", ncoll); } return OK; }
static int notowner_modify(void) { char *tmp; ne_propname pname = { "http://webdav.org/neon/litmus/", "random" }; ne_proppatch_operation pops[] = { { NULL, ne_propset, "foobar" }, { NULL } }; PRECOND(gotlock); pops[0].name = &pname; ONN("DELETE of locked resource should fail", ne_delete(i_session2, res) != NE_ERROR); if (STATUS2(423)) t_warning("DELETE failed with %d not 423", GETSTATUS2); tmp = ne_concat(i_path, "whocares", NULL); ONN("MOVE of locked resource should fail", ne_move(i_session2, 0, res, tmp) != NE_ERROR); free(tmp); if (STATUS2(423)) t_warning("MOVE failed with %d not 423", GETSTATUS2); ONN("COPY onto locked resource should fail", ne_copy(i_session2, 1, NE_DEPTH_ZERO, res2, res) != NE_ERROR); if (STATUS2(423)) t_warning("COPY failed with %d not 423", GETSTATUS2); ONN("PROPPATCH of locked resource should fail", ne_proppatch(i_session2, res, pops) != NE_ERROR); if (STATUS2(423)) t_warning("PROPPATCH failed with %d not 423", GETSTATUS2); ONN("PUT on locked resource should fail", ne_put(i_session2, res, i_foo_fd) != NE_ERROR); if (STATUS2(423)) t_warning("PUT failed with %d not 423", GETSTATUS2); return OK; }
int begin(void) { const char *scheme = use_secure?"https":"http"; char *space; static const char blanks[] = " "; static const char stars[] = "**********************************"; i_session = ne_session_create(scheme, i_hostname, i_port); CALL(init_session(i_session)); ne_hook_pre_send(i_session, i_pre_send, "X-Prestan"); space = ne_concat(i_path, "davtest/", NULL); ne_delete(i_session, space); if (ne_mkcol(i_session, space)) { t_context("Could not create new collection `%s' for tests: %s\n" "Server must allow `MKCOL %s' for tests to proceed", space, ne_get_error(i_session), space); return FAILHARD; } free(i_path); i_path = space; warmup(); printf("\nStart Testing %s:\n\n",pget_option.URL) ; printf("\n%s%s\n", blanks, stars); printf("\n%s* Number of Requests\t\t%d\n", blanks, pget_option.requests); printf("\n%s* Number of Dead Properties\t%d\n", blanks, pget_option.numprops); printf("\n%s* Depth of Collection\t\t%d\n", blanks, pget_option.depth); printf("\n%s* Width of Collection\t\t%d\n", blanks, pget_option.width); printf("\n%s* Type of Methods\t\t%s\n", blanks, pget_option.methods); printf("\n%s%s\n", blanks, stars); printf("\n\n"); return OK; }
static int owncloud_rmdir(const char *uri) { int rc = NE_OK; char* curi = _cleanPath( uri ); rc = dav_connect(uri); if (rc < 0) { errno = EINVAL; } if( rc >= 0 ) { rc = ne_delete(dav_session.ctx, curi); if ( rc != NE_OK ) { set_errno_from_session(); } } SAFE_FREE( curi ); if( rc < 0 || rc != NE_OK ) { return -1; } return 0; }
static int owncloud_unlink(const char *uri) { int rc = NE_OK; char *path = _cleanPath( uri ); if( ! path ) { rc = NE_ERROR; errno = EINVAL; } if( rc == NE_OK ) { rc = dav_connect(uri); if (rc < 0) { errno = EINVAL; } } if( rc == NE_OK ) { rc = ne_delete( dav_session.ctx, path ); if ( rc != NE_OK ) set_errno_from_session(); } SAFE_FREE( path ); return 0; }
static int move_coll(void) { int n; char *rsrc, *rdest, *subsrc, *subdest; char res[512]; msrc = ne_concat(i_path, "mvsrc/", NULL); mdest = ne_concat(i_path, "mvdest/", NULL); mdest2 = ne_concat(i_path, "mvdest2/", NULL); rsrc = ne_concat(i_path, "mvsrc/foo", NULL); rdest = ne_concat(i_path, "mvdest/foo", NULL); subsrc = ne_concat(i_path, "mvsrc/subcoll/", NULL); subdest = ne_concat(i_path, "mvdest/subcoll/", NULL); mnoncoll = ne_concat(i_path, "mvnoncoll", NULL); /* Set up the mvsrc collection. */ ONMREQ("MKCOL", msrc, ne_mkcol(i_session, msrc)); for (n = 0; n < 10; n++) { sprintf(res, "mvsrc/foo.%d", n); CALL(upload_foo(res)); } CALL(upload_foo("mvnoncoll")); ONV(ne_mkcol(i_session, subsrc), ("MKCOL of `%s' failed: %s\n", subsrc, SERR)); /* Now make a copy of the collection */ ONV(ne_copy(i_session, 0, NE_DEPTH_INFINITE, msrc, mdest2), ("collection COPY `%s' to `%s', depth infinity: %s", msrc, mdest2, SERR)); ONV(ne_move(i_session, 0, msrc, mdest), ("collection MOVE `%s' to `%s': %s", msrc, mdest, SERR)); ONN("MOVE-on-existing-coll should fail", ne_move(i_session, 0, mdest, mdest2) != NE_ERROR); ONN("MOVE-on-existing-coll with overwrite", ne_move(i_session, 1, mdest2, mdest)); /* Take another copy. */ ONV(ne_copy(i_session, 0, NE_DEPTH_INFINITE, mdest, mdest2), ("collection COPY `%s' to `%s', depth infinity: %s", mdest, mdest2, ne_get_error(i_session))); /* Now delete things out of the destination collection to check if * they are there. */ for (n = 0; n < 10; n++) { sprintf(res, "%s%s.%d", i_path, "mvdest/foo", n); ONV(ne_delete(i_session, res), ("DELETE from copied collection failed for `%s': %s", res, SERR)); } ONV(ne_delete(i_session, subdest), ("DELETE from copied collection failed for `%s': %s", subdest, SERR)); /* And move the spare collection over a non-coll. */ ONV(ne_move(i_session, 1, mdest2, mnoncoll), ("MOVE collection `%s' over non-collection `%s' with overwrite: %s", mdest2, mnoncoll, ne_get_error(i_session))); return OK; }
static int lock_on_no_file(void) { char *tmp; res = ne_concat(i_path, "locknullfile", NULL); tmp = ne_concat(i_path, "whocares", NULL); getlock(ne_lockscope_exclusive, NE_DEPTH_ZERO); if (STATUS(200)) t_warning("Lock Null failed with %d not 200", GETSTATUS); //FIXME: After Lock Null is created, Do Unlock it to maintain integrity of tests //ONNREQ2("unlock of second shared lock",ne_unlock(i_session, &gotlock)); // Copy of nulllock resource ONN("COPY null locked resource should ", ne_copy(i_session, 1, NE_DEPTH_ZERO, res, tmp) == NE_ERROR); // Delete of nulllockresource ONN("DELETE of locknull resource by owner", ne_delete(i_session, tmp) == NE_ERROR); free(tmp); // Move of nulllockresource tmp = ne_concat(i_path, "who-cares", NULL); ONN("MOVE of null-locked resource", ne_move(i_session, 0, res, tmp) == NE_ERROR); ONN("DELETE of locknull resource by owner after a MOVE with overwrite (F)", ne_delete(i_session, tmp) == NE_ERROR); /* Delete the locktoken from store */ ne_lockstore_remove(store, gotlock); getlock(ne_lockscope_exclusive, NE_DEPTH_ZERO); if (STATUS(200)) t_warning("Lock Null failed with %d not 200", GETSTATUS); /* Lot of code duplication, but want to test each case individually. * Locknull resource. How it behaves when it is copied * moved (with overwrite T/F) * PUT request on locknullresource should succeed. */ /*MOVE of null-locked resource with overwrite=T */ ONN("MOVE of null-locked resource with overwrite=T (1)", ne_move(i_session, 1, res, tmp) == NE_ERROR); ne_lockstore_remove(store, gotlock); getlock(ne_lockscope_exclusive, NE_DEPTH_ZERO); if (STATUS(200)) t_warning("Lock Null failed with %d not 200", GETSTATUS); ONN("MOVE of null-locked resource with overwrite=T (2)", ne_move(i_session, 1, res, tmp) == NE_ERROR); ne_lockstore_remove(store, gotlock); getlock(ne_lockscope_shared, NE_DEPTH_ZERO); if (STATUS(200)) t_warning("Lock Null failed with %d not 200", GETSTATUS); ONN("COPY on null-locked resource with overwrite=T", ne_copy(i_session, 1, NE_DEPTH_ZERO, tmp, res) == NE_ERROR); ONN("DELETE of locknull resource by owner after a MOVE (T) ", ne_delete(i_session, tmp) == NE_ERROR); free(tmp); // Put on nulllockresource ONV(ne_put(i_session,res, i_foo_fd), ("PUT on locknullfile resource failed: %s", ne_get_error(i_session))); return OK; }
Hbf_State hbf_transfer( ne_session *session, hbf_transfer_t *transfer, const char *verb ) { Hbf_State state = HBF_TRANSFER_SUCCESS; int cnt; if( ! session ) { state = HBF_SESSION_FAIL; } if( ! transfer ) { state = HBF_SPLITLIST_FAIL; } if( ! verb ) { state = HBF_PARAM_FAIL; } if(state == HBF_TRANSFER_SUCCESS) { DEBUG_HBF("%s request to %s", verb, transfer->url); } for( cnt=0; state == HBF_TRANSFER_SUCCESS && cnt < transfer->block_cnt; cnt++ ) { /* cnt goes from O to block_cnt, but block_id starts at start_id and wrap around * That way if we have not finished uploaded when we reach block_cnt, we re-upload * the beginning of the file that the server did not have in cache anymore. */ int block_id = (cnt + transfer->start_id) % transfer->block_cnt; hbf_block_t *block = transfer->block_arr[block_id]; char *transfer_url = NULL; if( ! block ) state = HBF_PARAM_FAIL; if( transfer->abort_cb ) { int do_abort = (transfer->abort_cb)(transfer->user_data); if( do_abort ) { state = HBF_USER_ABORTED; transfer->start_id = block_id % transfer->block_cnt; } } if( state == HBF_TRANSFER_SUCCESS ) { transfer_url = get_transfer_url( transfer, block_id ); if( ! transfer_url ) { state = HBF_PARAM_FAIL; } } if( state == HBF_TRANSFER_SUCCESS ) { if( transfer->block_cnt > 1 && cnt > 0 ) { /* The block count is > 1, check size and mtime before transmitting. */ state = hbf_validate_source_file(transfer); if( state == HBF_SOURCE_FILE_CHANGE ) { /* The source file has changed meanwhile */ } } } if( state == HBF_TRANSFER_SUCCESS || state == HBF_SUCCESS ) { ne_request *req = ne_request_create(session, verb, transfer_url); if( req ) { char buf[21]; snprintf(buf, sizeof(buf), "%"PRId64, transfer->stat_size); ne_add_request_header(req, "OC-Total-Length", buf); if( transfer->oc_header_modtime > 0 ) { snprintf(buf, sizeof(buf), "%"PRId64, transfer->oc_header_modtime); ne_add_request_header(req, "X-OC-Mtime", buf); } if( transfer->previous_etag ) { ne_add_request_header(req, "If-Match", transfer->previous_etag); } if( transfer->block_cnt > 1 ) { ne_add_request_header(req, "OC-Chunked", "1"); snprintf(buf, sizeof(buf), "%"PRId64, transfer->threshold); ne_add_request_header(req, "OC-Chunk-Size", buf); } ne_add_request_header( req, "Content-Type", "application/octet-stream"); state = _hbf_dav_request(transfer, req, transfer->fd, block ); if( state != HBF_TRANSFER_SUCCESS && state != HBF_SUCCESS) { if( transfer->error_string ) free( transfer->error_string ); transfer->error_string = strdup( ne_get_error(session) ); transfer->start_id = block_id % transfer->block_cnt; /* Set the code of the last transmission. */ state = HBF_FAIL; transfer->status_code = transfer->block_arr[block_id]->http_result_code; } ne_request_destroy(req); if (transfer->block_cnt > 1 && state == HBF_SUCCESS && cnt == 0) { /* Success on the first chunk is suspicious. It could happen that the server did not support chunking */ int rc = ne_delete(session, transfer_url); if (rc == NE_OK && _hbf_http_error_code(session) == 204) { /* If delete suceeded, it means some proxy strips the OC_CHUNKING header start again without chunking: */ free( transfer_url ); return _hbf_transfer_no_chunk(session, transfer, verb); } } if (state == HBF_TRANSFER_SUCCESS && transfer->chunk_finished_cb) { transfer->chunk_finished_cb(transfer, block_id, transfer->user_data); } } else { state = HBF_MEMORY_FAIL; } } free( transfer_url ); } /* do the source file validation finally (again). */ if( state == HBF_TRANSFER_SUCCESS ) { /* This means that no etag was returned on one of the chunks to indicate * that the upload was finished. */ state = HBF_TRANSFER_NOT_ACKED; } return state; }
int mc_del(DAL_Context* ctx) { char* path_template = MC_CONTEXT(ctx)->path_template; int nblocks = MC_CONFIG(ctx)->n + MC_CONFIG(ctx)->e; return ne_delete(path_template, nblocks); }
static int lockcleanup(void) { ne_delete(i_session, i_path); return OK; }
static int copy_coll(void) { int n; char *csrc, *cdest, *rsrc, *rdest, *subsrc, *subdest, *cdest2; char res[512]; csrc = ne_concat(i_path, "ccsrc/", NULL); cdest = ne_concat(i_path, "ccdest/", NULL); cdest2 = ne_concat(i_path, "ccdest2/", NULL); rsrc = ne_concat(i_path, "ccsrc/foo", NULL); rdest = ne_concat(i_path, "ccdest/foo", NULL); subsrc = ne_concat(i_path, "ccsrc/subcoll/", NULL); subdest = ne_concat(i_path, "ccdest/subcoll/", NULL); /* Set up the ccsrc collection. */ ONMREQ("MKCOL", csrc, ne_mkcol(i_session, csrc)); for (n = 0; n < 10; n++) { sprintf(res, "ccsrc/foo.%d", n); CALL(upload_foo(res)); } ONMREQ("MKCOL", subsrc, ne_mkcol(i_session, subsrc)); /* Clean up to make some fresh copies. */ ne_delete(i_session, cdest); ne_delete(i_session, cdest2); /* Now copy the collection a couple of times */ ONV(ne_copy(i_session, 0, NE_DEPTH_INFINITE, csrc, cdest), ("collection COPY `%s' to `%s': %s", csrc, cdest, ne_get_error(i_session))); ONV(ne_copy(i_session, 0, NE_DEPTH_INFINITE, csrc, cdest2), ("collection COPY `%s' to `%s': %s", csrc, cdest, ne_get_error(i_session))); ONN("COPY-on-existing-coll should fail", ne_copy(i_session, 0, NE_DEPTH_INFINITE, cdest, cdest2) != NE_ERROR); ONV(ne_copy(i_session, 1, NE_DEPTH_INFINITE, cdest2, cdest), ("COPY-on-existing-coll with overwrite: %s", ne_get_error(i_session))); /* Remove the source, to be paranoid. */ if (ne_delete(i_session, csrc)) { t_warning("Could not delete csrc"); } /* Now delete things out of the destination collection to check if * they are there. */ for (n = 0; n < 10; n++) { sprintf(res, "%s%s.%d", i_path, "ccdest/foo", n); ONV(ne_delete(i_session, res), ("COPY destination coll missing %s? %s", res, ne_get_error(i_session))); } ONV(ne_delete(i_session, subdest), ("COPY destination missing sub-coll %s? %s", subdest, ne_get_error(i_session))); /* Now nuke the whole of the second copy. */ ONV(ne_delete(i_session, cdest2), ("COPY destination %s missing? %s", cdest2, ne_get_error(i_session))); if (ne_delete(i_session, cdest)) { t_warning("Could not clean up cdest"); } return OK; }