static int prep_collection(void)
{
if (gotlock) {
ne_lock_destroy(gotlock);
gotlock = NULL;
}
ne_free(res);
res = coll = ne_concat(i_path, "lockcoll/", NULL);
ONV(ne_mkcol(i_session, res),
("MKCOL %s: %s", res, ne_get_error(i_session)));
return OK;
}
static void free_list(struct lock_list *list, int destroy)
{
struct lock_list *next;
while (list != NULL) {
next = list->next;
if (destroy)
ne_lock_destroy(list->lock);
ne_free(list);
list = next;
}
}
static void *ld_create(void *userdata, const char *href)
{
struct discover_ctx *ctx = userdata;
struct ne_lock *lk = ne_lock_create();
if (ne_uri_parse(href, &lk->uri) != 0) {
ne_lock_destroy(lk);
return NULL;
}
if (!lk->uri.host)
ne_fill_server_uri(ctx->session, &lk->uri);
return lk;
}
/* indirectly refresh the the collection lock */
static int indirect_refresh(void)
{
struct ne_lock *indirect;
PRECOND(gotlock);
indirect = ne_lock_copy(gotlock);
ne_free(indirect->uri.path);
indirect->uri.path = ne_strdup(res);
ONV(ne_lock_refresh(i_session, indirect),
("indirect refresh LOCK on %s via %s: %s",
coll, res, ne_get_error(i_session)));
ne_lock_destroy(indirect);
return OK;
}
/* lock on unmapped url should return 201 */
static int unmapped_lock(void)
{
if (gotlock) {
ne_lock_destroy(gotlock);
gotlock = NULL;
}
ne_free(res);
res = ne_concat(i_path, "unmapped_url", NULL);
ONV(getlock(ne_lockscope_exclusive, NE_DEPTH_ZERO),
("LOCK on %s via %s: %s",
coll, res, ne_get_error(i_session)));
if (STATUS(201))
t_warning("LOCK on unmapped url returned %d not 201 (RFC4918:S7.3)", GETSTATUS);
return OK;
}
static int prep_collection(void)
{
if (gotlock) {
ne_lock_destroy(gotlock);
gotlock = NULL;
}
ne_free(res);
ne_free(res3);
res = coll = ne_concat(i_path, "lockcoll/", NULL);
/* Setting directories for further tests */
collX = ne_concat(coll,"collX/",NULL);
collY = ne_concat(coll,"collY/",NULL);
res3 = ne_concat(collX,"temp",NULL);
collZ = ne_concat(i_path, "lockcoll2/", NULL);
ONV(ne_mkcol(i_session, res),
("MKCOL %s: %s", res, ne_get_error(i_session)));
ONV(ne_mkcol(i_session, collZ),
("MKCOL %s: %s", collZ, ne_get_error(i_session)));
return OK;
}
static void discover_results(void *userdata, const char *href,
const ne_prop_result_set *set)
{
struct discover_ctx *ctx = userdata;
struct ne_lock *lock = ne_propset_private(set);
const ne_status *status = ne_propset_status(set, &lock_props[0]);
/* Require at least that the lock has a token. */
if (lock->token) {
if (status && status->klass != 2) {
ctx->results(ctx->userdata, NULL, lock->uri.path, status);
} else {
ctx->results(ctx->userdata, lock, lock->uri.path, NULL);
}
}
else if (status) {
ctx->results(ctx->userdata, NULL, href, status);
}
ne_lock_destroy(lock);
NE_DEBUG(NE_DBG_LOCKS, "End of response for %s\n", href);
}
/* TODO: does this work under cygwin? mkstemp() may or may not open
the file using O_BINARY, and then we *do* upload it using O_BINARY,
so maybe this will screw things up. Maybe we should fcntl it and
set O_BINARY, if that is allowed under cygwin? */
void execute_edit(const char *remote)
{
char *real_remote;
unsigned int can_lock; /* can we LOCK it? */
struct ne_lock *lock = NULL;
char fname[PATH_MAX] = "/tmp/cadaver-edit-XXXXXX";
const char *pnt;
int fd;
int is_checkout, is_checkin;
real_remote = resolve_path(session.uri.path, remote, false);
/* Don't let them edit a collection, since PUT to a collection is
* bogus. Really we want to be able to fetch a "DefaultDocument"
* property, and edit on that instead: IIS does expose such a
* property. Would be a nice hack to add the support to mod_dav
* too. */
if (getrestype(real_remote) == resr_collection) {
printf(_("You cannot edit a collection resource (%s).\n"),
real_remote);
goto edit_bail;
}
can_lock = is_lockable(real_remote);
/* Give the local temp file the same extension as the remote path,
* so the editor can have a stab at the content-type. */
pnt = strrchr(real_remote, '.');
if (pnt != NULL && strchr(pnt, '/') == NULL) {
strncat(fname, pnt, PATH_MAX);
fname[PATH_MAX-1] = '\0';
}
fd = cad_mkstemp(fname);
if (fd == -1) {
printf(_("Could not create temporary file %s:\n%s\n"), fname,
strerror(errno));
goto edit_bail;
}
/* Sanity check on the file perms. */
#ifdef HAVE_FCHMOD
if (fchmod(fd, 0600) == -1) {
#else
if (chmod(fname, 0600) == -1) {
#endif
printf(_("Could not set file permissions for %s:\n%s\n"), fname,
strerror(errno));
goto edit_bail;
}
if (can_lock) {
lock = ne_lock_create();
ne_fill_server_uri(session.sess, &lock->uri);
lock->uri.path = ne_strdup(real_remote);
lock->owner = getowner();
out_start("Locking", remote);
if (out_handle(ne_lock(session.sess, lock))) {
ne_lockstore_add(session.locks, lock);
} else {
ne_lock_destroy(lock);
goto edit_close;
}
} else {
/* TODO: HEAD and get the Etag/modtime */
}
/* Return 1: Checkin, 2: Checkout, 0: otherwise */
is_checkin = is_vcr(real_remote);
if (is_checkin==1) {
execute_checkout(real_remote);
}
output(o_download, _("Downloading `%s' to %s"), real_remote, fname);
/* Don't puke if get fails -- perhaps we are creating a new one? */
out_result(ne_get(session.sess, real_remote, fd));
if (close(fd)) {
output(o_finish, _("Error writing to temporary file: %s\n"),
strerror(errno));
}
else if (!run_editor(fname)) {
int upload_okay = 0;
fd = open(fname, O_RDONLY | OPEN_BINARY_FLAGS);
if (fd < 0) {
output(o_finish,
_("Could not re-open temporary file: %s\n"),
strerror(errno));
} else {
do {
output(o_upload, _("Uploading changes to `%s'"), real_remote);
/* FIXME: conditional PUT using fetched Etag/modtime if
* !can_lock */
if (out_handle(ne_put(session.sess, real_remote, fd))) {
upload_okay = 1;
} else {
/* TODO: offer to save locally instead */
printf(_("Try uploading again (y/n)? "));
if (!yesno()) {
upload_okay = 1;
}
}
} while (!upload_okay);
close(fd);
}
}
if (unlink(fname)) {
printf(_("Could not delete temporary file %s:\n%s\n"), fname,
strerror(errno));
}
/* Return 1: Checkin, 2: Checkout, 0: otherwise */
is_checkout = is_vcr(real_remote);
if (is_checkout==2) {
execute_checkin(real_remote);
}
/* UNLOCK it again whether we succeed or failed in our mission */
if (can_lock) {
output(o_start, "Unlocking `%s':", remote);
out_result(ne_unlock(session.sess, lock));
ne_lockstore_remove(session.locks, lock);
ne_lock_destroy(lock);
}
goto edit_bail;
edit_close:
close(fd);
edit_bail:
free(real_remote);
return;
}
