Annotation of embedaddon/lighttpd/src/mod_webdav.c, revision 1.1
1.1 ! misho 1: #include "base.h"
! 2: #include "log.h"
! 3: #include "buffer.h"
! 4: #include "response.h"
! 5:
! 6: #include "plugin.h"
! 7:
! 8: #include "stream.h"
! 9: #include "stat_cache.h"
! 10:
! 11: #include "sys-mmap.h"
! 12:
! 13: #include <sys/types.h>
! 14: #include <sys/stat.h>
! 15: #include <ctype.h>
! 16: #include <stdlib.h>
! 17: #include <string.h>
! 18: #include <errno.h>
! 19: #include <fcntl.h>
! 20: #include <stdio.h>
! 21: #include <assert.h>
! 22:
! 23: #include <unistd.h>
! 24: #include <dirent.h>
! 25:
! 26: #if defined(HAVE_LIBXML_H) && defined(HAVE_SQLITE3_H)
! 27: #define USE_PROPPATCH
! 28: #include <libxml/tree.h>
! 29: #include <libxml/parser.h>
! 30:
! 31: #include <sqlite3.h>
! 32: #endif
! 33:
! 34: #if defined(HAVE_LIBXML_H) && defined(HAVE_SQLITE3_H) && defined(HAVE_UUID_UUID_H)
! 35: #define USE_LOCKS
! 36: #include <uuid/uuid.h>
! 37: #endif
! 38:
! 39: /**
! 40: * this is a webdav for a lighttpd plugin
! 41: *
! 42: * at least a very basic one.
! 43: * - for now it is read-only and we only support PROPFIND
! 44: *
! 45: */
! 46:
! 47: #define WEBDAV_FILE_MODE S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH
! 48: #define WEBDAV_DIR_MODE S_IRWXU | S_IRWXG | S_IRWXO
! 49:
! 50: /* plugin config for all request/connections */
! 51:
! 52: typedef struct {
! 53: unsigned short enabled;
! 54: unsigned short is_readonly;
! 55: unsigned short log_xml;
! 56:
! 57: buffer *sqlite_db_name;
! 58: #ifdef USE_PROPPATCH
! 59: sqlite3 *sql;
! 60: sqlite3_stmt *stmt_update_prop;
! 61: sqlite3_stmt *stmt_delete_prop;
! 62: sqlite3_stmt *stmt_select_prop;
! 63: sqlite3_stmt *stmt_select_propnames;
! 64:
! 65: sqlite3_stmt *stmt_delete_uri;
! 66: sqlite3_stmt *stmt_move_uri;
! 67: sqlite3_stmt *stmt_copy_uri;
! 68:
! 69: sqlite3_stmt *stmt_remove_lock;
! 70: sqlite3_stmt *stmt_create_lock;
! 71: sqlite3_stmt *stmt_read_lock;
! 72: sqlite3_stmt *stmt_read_lock_by_uri;
! 73: sqlite3_stmt *stmt_refresh_lock;
! 74: #endif
! 75: } plugin_config;
! 76:
! 77: typedef struct {
! 78: PLUGIN_DATA;
! 79:
! 80: buffer *tmp_buf;
! 81: request_uri uri;
! 82: physical physical;
! 83:
! 84: plugin_config **config_storage;
! 85:
! 86: plugin_config conf;
! 87: } plugin_data;
! 88:
! 89: /* init the plugin data */
! 90: INIT_FUNC(mod_webdav_init) {
! 91: plugin_data *p;
! 92:
! 93: p = calloc(1, sizeof(*p));
! 94:
! 95: p->tmp_buf = buffer_init();
! 96:
! 97: p->uri.scheme = buffer_init();
! 98: p->uri.path_raw = buffer_init();
! 99: p->uri.path = buffer_init();
! 100: p->uri.authority = buffer_init();
! 101:
! 102: p->physical.path = buffer_init();
! 103: p->physical.rel_path = buffer_init();
! 104: p->physical.doc_root = buffer_init();
! 105: p->physical.basedir = buffer_init();
! 106:
! 107: return p;
! 108: }
! 109:
! 110: /* detroy the plugin data */
! 111: FREE_FUNC(mod_webdav_free) {
! 112: plugin_data *p = p_d;
! 113:
! 114: UNUSED(srv);
! 115:
! 116: if (!p) return HANDLER_GO_ON;
! 117:
! 118: if (p->config_storage) {
! 119: size_t i;
! 120: for (i = 0; i < srv->config_context->used; i++) {
! 121: plugin_config *s = p->config_storage[i];
! 122:
! 123: if (!s) continue;
! 124:
! 125: buffer_free(s->sqlite_db_name);
! 126: #ifdef USE_PROPPATCH
! 127: if (s->sql) {
! 128: sqlite3_finalize(s->stmt_delete_prop);
! 129: sqlite3_finalize(s->stmt_delete_uri);
! 130: sqlite3_finalize(s->stmt_copy_uri);
! 131: sqlite3_finalize(s->stmt_move_uri);
! 132: sqlite3_finalize(s->stmt_update_prop);
! 133: sqlite3_finalize(s->stmt_select_prop);
! 134: sqlite3_finalize(s->stmt_select_propnames);
! 135:
! 136: sqlite3_finalize(s->stmt_read_lock);
! 137: sqlite3_finalize(s->stmt_read_lock_by_uri);
! 138: sqlite3_finalize(s->stmt_create_lock);
! 139: sqlite3_finalize(s->stmt_remove_lock);
! 140: sqlite3_finalize(s->stmt_refresh_lock);
! 141: sqlite3_close(s->sql);
! 142: }
! 143: #endif
! 144: free(s);
! 145: }
! 146: free(p->config_storage);
! 147: }
! 148:
! 149: buffer_free(p->uri.scheme);
! 150: buffer_free(p->uri.path_raw);
! 151: buffer_free(p->uri.path);
! 152: buffer_free(p->uri.authority);
! 153:
! 154: buffer_free(p->physical.path);
! 155: buffer_free(p->physical.rel_path);
! 156: buffer_free(p->physical.doc_root);
! 157: buffer_free(p->physical.basedir);
! 158:
! 159: buffer_free(p->tmp_buf);
! 160:
! 161: free(p);
! 162:
! 163: return HANDLER_GO_ON;
! 164: }
! 165:
! 166: /* handle plugin config and check values */
! 167:
! 168: SETDEFAULTS_FUNC(mod_webdav_set_defaults) {
! 169: plugin_data *p = p_d;
! 170: size_t i = 0;
! 171:
! 172: config_values_t cv[] = {
! 173: { "webdav.activate", NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION }, /* 0 */
! 174: { "webdav.is-readonly", NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION }, /* 1 */
! 175: { "webdav.sqlite-db-name", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION }, /* 2 */
! 176: { "webdav.log-xml", NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION }, /* 3 */
! 177: { NULL, NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET }
! 178: };
! 179:
! 180: if (!p) return HANDLER_ERROR;
! 181:
! 182: p->config_storage = calloc(1, srv->config_context->used * sizeof(specific_config *));
! 183:
! 184: for (i = 0; i < srv->config_context->used; i++) {
! 185: plugin_config *s;
! 186:
! 187: s = calloc(1, sizeof(plugin_config));
! 188: s->sqlite_db_name = buffer_init();
! 189:
! 190: cv[0].destination = &(s->enabled);
! 191: cv[1].destination = &(s->is_readonly);
! 192: cv[2].destination = s->sqlite_db_name;
! 193: cv[3].destination = &(s->log_xml);
! 194:
! 195: p->config_storage[i] = s;
! 196:
! 197: if (0 != config_insert_values_global(srv, ((data_config *)srv->config_context->data[i])->value, cv)) {
! 198: return HANDLER_ERROR;
! 199: }
! 200:
! 201: if (!buffer_is_empty(s->sqlite_db_name)) {
! 202: #ifdef USE_PROPPATCH
! 203: const char *next_stmt;
! 204: char *err;
! 205:
! 206: if (SQLITE_OK != sqlite3_open(s->sqlite_db_name->ptr, &(s->sql))) {
! 207: log_error_write(srv, __FILE__, __LINE__, "sbs", "sqlite3_open failed for",
! 208: s->sqlite_db_name,
! 209: sqlite3_errmsg(s->sql));
! 210: return HANDLER_ERROR;
! 211: }
! 212:
! 213: if (SQLITE_OK != sqlite3_exec(s->sql,
! 214: "CREATE TABLE properties ("
! 215: " resource TEXT NOT NULL,"
! 216: " prop TEXT NOT NULL,"
! 217: " ns TEXT NOT NULL,"
! 218: " value TEXT NOT NULL,"
! 219: " PRIMARY KEY(resource, prop, ns))",
! 220: NULL, NULL, &err)) {
! 221:
! 222: if (0 != strcmp(err, "table properties already exists")) {
! 223: log_error_write(srv, __FILE__, __LINE__, "ss", "can't open transaction:", err);
! 224: sqlite3_free(err);
! 225:
! 226: return HANDLER_ERROR;
! 227: }
! 228: sqlite3_free(err);
! 229: }
! 230:
! 231: if (SQLITE_OK != sqlite3_prepare(s->sql,
! 232: CONST_STR_LEN("SELECT value FROM properties WHERE resource = ? AND prop = ? AND ns = ?"),
! 233: &(s->stmt_select_prop), &next_stmt)) {
! 234: /* prepare failed */
! 235:
! 236: log_error_write(srv, __FILE__, __LINE__, "ss", "sqlite3_prepare failed:", sqlite3_errmsg(s->sql));
! 237: return HANDLER_ERROR;
! 238: }
! 239:
! 240: if (SQLITE_OK != sqlite3_prepare(s->sql,
! 241: CONST_STR_LEN("SELECT ns, prop FROM properties WHERE resource = ?"),
! 242: &(s->stmt_select_propnames), &next_stmt)) {
! 243: /* prepare failed */
! 244:
! 245: log_error_write(srv, __FILE__, __LINE__, "ss", "sqlite3_prepare failed:", sqlite3_errmsg(s->sql));
! 246: return HANDLER_ERROR;
! 247: }
! 248:
! 249:
! 250: if (SQLITE_OK != sqlite3_prepare(s->sql,
! 251: CONST_STR_LEN("REPLACE INTO properties (resource, prop, ns, value) VALUES (?, ?, ?, ?)"),
! 252: &(s->stmt_update_prop), &next_stmt)) {
! 253: /* prepare failed */
! 254:
! 255: log_error_write(srv, __FILE__, __LINE__, "ss", "sqlite3_prepare failed:", sqlite3_errmsg(s->sql));
! 256: return HANDLER_ERROR;
! 257: }
! 258:
! 259: if (SQLITE_OK != sqlite3_prepare(s->sql,
! 260: CONST_STR_LEN("DELETE FROM properties WHERE resource = ? AND prop = ? AND ns = ?"),
! 261: &(s->stmt_delete_prop), &next_stmt)) {
! 262: /* prepare failed */
! 263: log_error_write(srv, __FILE__, __LINE__, "ss", "sqlite3_prepare failed", sqlite3_errmsg(s->sql));
! 264:
! 265: return HANDLER_ERROR;
! 266: }
! 267:
! 268: if (SQLITE_OK != sqlite3_prepare(s->sql,
! 269: CONST_STR_LEN("DELETE FROM properties WHERE resource = ?"),
! 270: &(s->stmt_delete_uri), &next_stmt)) {
! 271: /* prepare failed */
! 272: log_error_write(srv, __FILE__, __LINE__, "ss", "sqlite3_prepare failed", sqlite3_errmsg(s->sql));
! 273:
! 274: return HANDLER_ERROR;
! 275: }
! 276:
! 277: if (SQLITE_OK != sqlite3_prepare(s->sql,
! 278: CONST_STR_LEN("INSERT INTO properties SELECT ?, prop, ns, value FROM properties WHERE resource = ?"),
! 279: &(s->stmt_copy_uri), &next_stmt)) {
! 280: /* prepare failed */
! 281: log_error_write(srv, __FILE__, __LINE__, "ss", "sqlite3_prepare failed", sqlite3_errmsg(s->sql));
! 282:
! 283: return HANDLER_ERROR;
! 284: }
! 285:
! 286: if (SQLITE_OK != sqlite3_prepare(s->sql,
! 287: CONST_STR_LEN("UPDATE properties SET resource = ? WHERE resource = ?"),
! 288: &(s->stmt_move_uri), &next_stmt)) {
! 289: /* prepare failed */
! 290: log_error_write(srv, __FILE__, __LINE__, "ss", "sqlite3_prepare failed", sqlite3_errmsg(s->sql));
! 291:
! 292: return HANDLER_ERROR;
! 293: }
! 294:
! 295: /* LOCKS */
! 296:
! 297: if (SQLITE_OK != sqlite3_exec(s->sql,
! 298: "CREATE TABLE locks ("
! 299: " locktoken TEXT NOT NULL,"
! 300: " resource TEXT NOT NULL,"
! 301: " lockscope TEXT NOT NULL,"
! 302: " locktype TEXT NOT NULL,"
! 303: " owner TEXT NOT NULL,"
! 304: " depth INT NOT NULL,"
! 305: " timeout TIMESTAMP NOT NULL,"
! 306: " PRIMARY KEY(locktoken))",
! 307: NULL, NULL, &err)) {
! 308:
! 309: if (0 != strcmp(err, "table locks already exists")) {
! 310: log_error_write(srv, __FILE__, __LINE__, "ss", "can't open transaction:", err);
! 311: sqlite3_free(err);
! 312:
! 313: return HANDLER_ERROR;
! 314: }
! 315: sqlite3_free(err);
! 316: }
! 317:
! 318: if (SQLITE_OK != sqlite3_prepare(s->sql,
! 319: CONST_STR_LEN("INSERT INTO locks (locktoken, resource, lockscope, locktype, owner, depth, timeout) VALUES (?,?,?,?,?,?, CURRENT_TIME + 600)"),
! 320: &(s->stmt_create_lock), &next_stmt)) {
! 321: /* prepare failed */
! 322: log_error_write(srv, __FILE__, __LINE__, "ss", "sqlite3_prepare failed", sqlite3_errmsg(s->sql));
! 323:
! 324: return HANDLER_ERROR;
! 325: }
! 326:
! 327: if (SQLITE_OK != sqlite3_prepare(s->sql,
! 328: CONST_STR_LEN("DELETE FROM locks WHERE locktoken = ?"),
! 329: &(s->stmt_remove_lock), &next_stmt)) {
! 330: /* prepare failed */
! 331: log_error_write(srv, __FILE__, __LINE__, "ss", "sqlite3_prepare failed", sqlite3_errmsg(s->sql));
! 332:
! 333: return HANDLER_ERROR;
! 334: }
! 335:
! 336: if (SQLITE_OK != sqlite3_prepare(s->sql,
! 337: CONST_STR_LEN("SELECT locktoken, resource, lockscope, locktype, owner, depth, timeout FROM locks WHERE locktoken = ?"),
! 338: &(s->stmt_read_lock), &next_stmt)) {
! 339: /* prepare failed */
! 340: log_error_write(srv, __FILE__, __LINE__, "ss", "sqlite3_prepare failed", sqlite3_errmsg(s->sql));
! 341:
! 342: return HANDLER_ERROR;
! 343: }
! 344:
! 345: if (SQLITE_OK != sqlite3_prepare(s->sql,
! 346: CONST_STR_LEN("SELECT locktoken, resource, lockscope, locktype, owner, depth, timeout FROM locks WHERE resource = ?"),
! 347: &(s->stmt_read_lock_by_uri), &next_stmt)) {
! 348: /* prepare failed */
! 349: log_error_write(srv, __FILE__, __LINE__, "ss", "sqlite3_prepare failed", sqlite3_errmsg(s->sql));
! 350:
! 351: return HANDLER_ERROR;
! 352: }
! 353:
! 354: if (SQLITE_OK != sqlite3_prepare(s->sql,
! 355: CONST_STR_LEN("UPDATE locks SET timeout = CURRENT_TIME + 600 WHERE locktoken = ?"),
! 356: &(s->stmt_refresh_lock), &next_stmt)) {
! 357: /* prepare failed */
! 358: log_error_write(srv, __FILE__, __LINE__, "ss", "sqlite3_prepare failed", sqlite3_errmsg(s->sql));
! 359:
! 360: return HANDLER_ERROR;
! 361: }
! 362:
! 363:
! 364: #else
! 365: log_error_write(srv, __FILE__, __LINE__, "s", "Sorry, no sqlite3 and libxml2 support include, compile with --with-webdav-props");
! 366: return HANDLER_ERROR;
! 367: #endif
! 368: }
! 369: }
! 370:
! 371: return HANDLER_GO_ON;
! 372: }
! 373:
! 374: #define PATCH_OPTION(x) \
! 375: p->conf.x = s->x;
! 376: static int mod_webdav_patch_connection(server *srv, connection *con, plugin_data *p) {
! 377: size_t i, j;
! 378: plugin_config *s = p->config_storage[0];
! 379:
! 380: PATCH_OPTION(enabled);
! 381: PATCH_OPTION(is_readonly);
! 382: PATCH_OPTION(log_xml);
! 383:
! 384: #ifdef USE_PROPPATCH
! 385: PATCH_OPTION(sql);
! 386: PATCH_OPTION(stmt_update_prop);
! 387: PATCH_OPTION(stmt_delete_prop);
! 388: PATCH_OPTION(stmt_select_prop);
! 389: PATCH_OPTION(stmt_select_propnames);
! 390:
! 391: PATCH_OPTION(stmt_delete_uri);
! 392: PATCH_OPTION(stmt_move_uri);
! 393: PATCH_OPTION(stmt_copy_uri);
! 394:
! 395: PATCH_OPTION(stmt_remove_lock);
! 396: PATCH_OPTION(stmt_refresh_lock);
! 397: PATCH_OPTION(stmt_create_lock);
! 398: PATCH_OPTION(stmt_read_lock);
! 399: PATCH_OPTION(stmt_read_lock_by_uri);
! 400: #endif
! 401: /* skip the first, the global context */
! 402: for (i = 1; i < srv->config_context->used; i++) {
! 403: data_config *dc = (data_config *)srv->config_context->data[i];
! 404: s = p->config_storage[i];
! 405:
! 406: /* condition didn't match */
! 407: if (!config_check_cond(srv, con, dc)) continue;
! 408:
! 409: /* merge config */
! 410: for (j = 0; j < dc->value->used; j++) {
! 411: data_unset *du = dc->value->data[j];
! 412:
! 413: if (buffer_is_equal_string(du->key, CONST_STR_LEN("webdav.activate"))) {
! 414: PATCH_OPTION(enabled);
! 415: } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("webdav.is-readonly"))) {
! 416: PATCH_OPTION(is_readonly);
! 417: } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("webdav.log-xml"))) {
! 418: PATCH_OPTION(log_xml);
! 419: } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("webdav.sqlite-db-name"))) {
! 420: #ifdef USE_PROPPATCH
! 421: PATCH_OPTION(sql);
! 422: PATCH_OPTION(stmt_update_prop);
! 423: PATCH_OPTION(stmt_delete_prop);
! 424: PATCH_OPTION(stmt_select_prop);
! 425: PATCH_OPTION(stmt_select_propnames);
! 426:
! 427: PATCH_OPTION(stmt_delete_uri);
! 428: PATCH_OPTION(stmt_move_uri);
! 429: PATCH_OPTION(stmt_copy_uri);
! 430:
! 431: PATCH_OPTION(stmt_remove_lock);
! 432: PATCH_OPTION(stmt_refresh_lock);
! 433: PATCH_OPTION(stmt_create_lock);
! 434: PATCH_OPTION(stmt_read_lock);
! 435: PATCH_OPTION(stmt_read_lock_by_uri);
! 436: #endif
! 437: }
! 438: }
! 439: }
! 440:
! 441: return 0;
! 442: }
! 443:
! 444: URIHANDLER_FUNC(mod_webdav_uri_handler) {
! 445: plugin_data *p = p_d;
! 446:
! 447: UNUSED(srv);
! 448:
! 449: if (con->uri.path->used == 0) return HANDLER_GO_ON;
! 450:
! 451: mod_webdav_patch_connection(srv, con, p);
! 452:
! 453: if (!p->conf.enabled) return HANDLER_GO_ON;
! 454:
! 455: switch (con->request.http_method) {
! 456: case HTTP_METHOD_OPTIONS:
! 457: /* we fake a little bit but it makes MS W2k happy and it let's us mount the volume */
! 458: response_header_overwrite(srv, con, CONST_STR_LEN("DAV"), CONST_STR_LEN("1,2"));
! 459: response_header_overwrite(srv, con, CONST_STR_LEN("MS-Author-Via"), CONST_STR_LEN("DAV"));
! 460:
! 461: if (p->conf.is_readonly) {
! 462: response_header_insert(srv, con, CONST_STR_LEN("Allow"), CONST_STR_LEN("PROPFIND"));
! 463: } else {
! 464: response_header_insert(srv, con, CONST_STR_LEN("Allow"), CONST_STR_LEN("PROPFIND, DELETE, MKCOL, PUT, MOVE, COPY, PROPPATCH, LOCK, UNLOCK"));
! 465: }
! 466: break;
! 467: default:
! 468: break;
! 469: }
! 470:
! 471: /* not found */
! 472: return HANDLER_GO_ON;
! 473: }
! 474: static int webdav_gen_prop_tag(server *srv, connection *con,
! 475: char *prop_name,
! 476: char *prop_ns,
! 477: char *value,
! 478: buffer *b) {
! 479:
! 480: UNUSED(srv);
! 481: UNUSED(con);
! 482:
! 483: if (value) {
! 484: buffer_append_string_len(b,CONST_STR_LEN("<"));
! 485: buffer_append_string(b, prop_name);
! 486: buffer_append_string_len(b, CONST_STR_LEN(" xmlns=\""));
! 487: buffer_append_string(b, prop_ns);
! 488: buffer_append_string_len(b, CONST_STR_LEN("\">"));
! 489:
! 490: buffer_append_string(b, value);
! 491:
! 492: buffer_append_string_len(b,CONST_STR_LEN("</"));
! 493: buffer_append_string(b, prop_name);
! 494: buffer_append_string_len(b, CONST_STR_LEN(">"));
! 495: } else {
! 496: buffer_append_string_len(b,CONST_STR_LEN("<"));
! 497: buffer_append_string(b, prop_name);
! 498: buffer_append_string_len(b, CONST_STR_LEN(" xmlns=\""));
! 499: buffer_append_string(b, prop_ns);
! 500: buffer_append_string_len(b, CONST_STR_LEN("\"/>"));
! 501: }
! 502:
! 503: return 0;
! 504: }
! 505:
! 506:
! 507: static int webdav_gen_response_status_tag(server *srv, connection *con, physical *dst, int status, buffer *b) {
! 508: UNUSED(srv);
! 509:
! 510: buffer_append_string_len(b,CONST_STR_LEN("<D:response xmlns:ns0=\"urn:uuid:c2f41010-65b3-11d1-a29f-00aa00c14882/\">\n"));
! 511:
! 512: buffer_append_string_len(b,CONST_STR_LEN("<D:href>\n"));
! 513: buffer_append_string_buffer(b, dst->rel_path);
! 514: buffer_append_string_len(b,CONST_STR_LEN("</D:href>\n"));
! 515: buffer_append_string_len(b,CONST_STR_LEN("<D:status>\n"));
! 516:
! 517: if (con->request.http_version == HTTP_VERSION_1_1) {
! 518: buffer_copy_string_len(b, CONST_STR_LEN("HTTP/1.1 "));
! 519: } else {
! 520: buffer_copy_string_len(b, CONST_STR_LEN("HTTP/1.0 "));
! 521: }
! 522: buffer_append_long(b, status);
! 523: buffer_append_string_len(b, CONST_STR_LEN(" "));
! 524: buffer_append_string(b, get_http_status_name(status));
! 525:
! 526: buffer_append_string_len(b,CONST_STR_LEN("</D:status>\n"));
! 527: buffer_append_string_len(b,CONST_STR_LEN("</D:response>\n"));
! 528:
! 529: return 0;
! 530: }
! 531:
! 532: static int webdav_delete_file(server *srv, connection *con, plugin_data *p, physical *dst, buffer *b) {
! 533: int status = 0;
! 534:
! 535: /* try to unlink it */
! 536: if (-1 == unlink(dst->path->ptr)) {
! 537: switch(errno) {
! 538: case EACCES:
! 539: case EPERM:
! 540: /* 403 */
! 541: status = 403;
! 542: break;
! 543: default:
! 544: status = 501;
! 545: break;
! 546: }
! 547: webdav_gen_response_status_tag(srv, con, dst, status, b);
! 548: } else {
! 549: #ifdef USE_PROPPATCH
! 550: sqlite3_stmt *stmt = p->conf.stmt_delete_uri;
! 551:
! 552: if (!stmt) {
! 553: status = 403;
! 554: webdav_gen_response_status_tag(srv, con, dst, status, b);
! 555: } else {
! 556: sqlite3_reset(stmt);
! 557:
! 558: /* bind the values to the insert */
! 559:
! 560: sqlite3_bind_text(stmt, 1,
! 561: dst->rel_path->ptr,
! 562: dst->rel_path->used - 1,
! 563: SQLITE_TRANSIENT);
! 564:
! 565: if (SQLITE_DONE != sqlite3_step(stmt)) {
! 566: /* */
! 567: }
! 568: }
! 569: #else
! 570: UNUSED(p);
! 571: #endif
! 572: }
! 573:
! 574: return (status != 0);
! 575: }
! 576:
! 577: static int webdav_delete_dir(server *srv, connection *con, plugin_data *p, physical *dst, buffer *b) {
! 578: DIR *dir;
! 579: int have_multi_status = 0;
! 580: physical d;
! 581:
! 582: d.path = buffer_init();
! 583: d.rel_path = buffer_init();
! 584:
! 585: if (NULL != (dir = opendir(dst->path->ptr))) {
! 586: struct dirent *de;
! 587:
! 588: while(NULL != (de = readdir(dir))) {
! 589: struct stat st;
! 590: int status = 0;
! 591:
! 592: if ((de->d_name[0] == '.' && de->d_name[1] == '\0') ||
! 593: (de->d_name[0] == '.' && de->d_name[1] == '.' && de->d_name[2] == '\0')) {
! 594: continue;
! 595: /* ignore the parent dir */
! 596: }
! 597:
! 598: buffer_copy_string_buffer(d.path, dst->path);
! 599: BUFFER_APPEND_SLASH(d.path);
! 600: buffer_append_string(d.path, de->d_name);
! 601:
! 602: buffer_copy_string_buffer(d.rel_path, dst->rel_path);
! 603: BUFFER_APPEND_SLASH(d.rel_path);
! 604: buffer_append_string(d.rel_path, de->d_name);
! 605:
! 606: /* stat and unlink afterwards */
! 607: if (-1 == stat(d.path->ptr, &st)) {
! 608: /* don't about it yet, rmdir will fail too */
! 609: } else if (S_ISDIR(st.st_mode)) {
! 610: have_multi_status = webdav_delete_dir(srv, con, p, &d, b);
! 611:
! 612: /* try to unlink it */
! 613: if (-1 == rmdir(d.path->ptr)) {
! 614: switch(errno) {
! 615: case EACCES:
! 616: case EPERM:
! 617: /* 403 */
! 618: status = 403;
! 619: break;
! 620: default:
! 621: status = 501;
! 622: break;
! 623: }
! 624: have_multi_status = 1;
! 625:
! 626: webdav_gen_response_status_tag(srv, con, &d, status, b);
! 627: } else {
! 628: #ifdef USE_PROPPATCH
! 629: sqlite3_stmt *stmt = p->conf.stmt_delete_uri;
! 630:
! 631: status = 0;
! 632:
! 633: if (stmt) {
! 634: sqlite3_reset(stmt);
! 635:
! 636: /* bind the values to the insert */
! 637:
! 638: sqlite3_bind_text(stmt, 1,
! 639: d.rel_path->ptr,
! 640: d.rel_path->used - 1,
! 641: SQLITE_TRANSIENT);
! 642:
! 643: if (SQLITE_DONE != sqlite3_step(stmt)) {
! 644: /* */
! 645: }
! 646: }
! 647: #endif
! 648: }
! 649: } else {
! 650: have_multi_status = webdav_delete_file(srv, con, p, &d, b);
! 651: }
! 652: }
! 653: closedir(dir);
! 654:
! 655: buffer_free(d.path);
! 656: buffer_free(d.rel_path);
! 657: }
! 658:
! 659: return have_multi_status;
! 660: }
! 661:
! 662: static int webdav_copy_file(server *srv, connection *con, plugin_data *p, physical *src, physical *dst, int overwrite) {
! 663: stream s;
! 664: int status = 0, ofd;
! 665: UNUSED(srv);
! 666: UNUSED(con);
! 667:
! 668: if (stream_open(&s, src->path)) {
! 669: return 403;
! 670: }
! 671:
! 672: if (-1 == (ofd = open(dst->path->ptr, O_WRONLY|O_TRUNC|O_CREAT|(overwrite ? 0 : O_EXCL), WEBDAV_FILE_MODE))) {
! 673: /* opening the destination failed for some reason */
! 674: switch(errno) {
! 675: case EEXIST:
! 676: status = 412;
! 677: break;
! 678: case EISDIR:
! 679: status = 409;
! 680: break;
! 681: case ENOENT:
! 682: /* at least one part in the middle wasn't existing */
! 683: status = 409;
! 684: break;
! 685: default:
! 686: status = 403;
! 687: break;
! 688: }
! 689: stream_close(&s);
! 690: return status;
! 691: }
! 692:
! 693: if (-1 == write(ofd, s.start, s.size)) {
! 694: switch(errno) {
! 695: case ENOSPC:
! 696: status = 507;
! 697: break;
! 698: default:
! 699: status = 403;
! 700: break;
! 701: }
! 702: }
! 703:
! 704: stream_close(&s);
! 705: close(ofd);
! 706:
! 707: #ifdef USE_PROPPATCH
! 708: if (0 == status) {
! 709: /* copy worked fine, copy connected properties */
! 710: sqlite3_stmt *stmt = p->conf.stmt_copy_uri;
! 711:
! 712: if (stmt) {
! 713: sqlite3_reset(stmt);
! 714:
! 715: /* bind the values to the insert */
! 716: sqlite3_bind_text(stmt, 1,
! 717: dst->rel_path->ptr,
! 718: dst->rel_path->used - 1,
! 719: SQLITE_TRANSIENT);
! 720:
! 721: sqlite3_bind_text(stmt, 2,
! 722: src->rel_path->ptr,
! 723: src->rel_path->used - 1,
! 724: SQLITE_TRANSIENT);
! 725:
! 726: if (SQLITE_DONE != sqlite3_step(stmt)) {
! 727: /* */
! 728: }
! 729: }
! 730: }
! 731: #else
! 732: UNUSED(p);
! 733: #endif
! 734: return status;
! 735: }
! 736:
! 737: static int webdav_copy_dir(server *srv, connection *con, plugin_data *p, physical *src, physical *dst, int overwrite) {
! 738: DIR *srcdir;
! 739: int status = 0;
! 740:
! 741: if (NULL != (srcdir = opendir(src->path->ptr))) {
! 742: struct dirent *de;
! 743: physical s, d;
! 744:
! 745: s.path = buffer_init();
! 746: s.rel_path = buffer_init();
! 747:
! 748: d.path = buffer_init();
! 749: d.rel_path = buffer_init();
! 750:
! 751: while (NULL != (de = readdir(srcdir))) {
! 752: struct stat st;
! 753:
! 754: if ((de->d_name[0] == '.' && de->d_name[1] == '\0') ||
! 755: (de->d_name[0] == '.' && de->d_name[1] == '.' && de->d_name[2] == '\0')) {
! 756: continue;
! 757: }
! 758:
! 759: buffer_copy_string_buffer(s.path, src->path);
! 760: BUFFER_APPEND_SLASH(s.path);
! 761: buffer_append_string(s.path, de->d_name);
! 762:
! 763: buffer_copy_string_buffer(d.path, dst->path);
! 764: BUFFER_APPEND_SLASH(d.path);
! 765: buffer_append_string(d.path, de->d_name);
! 766:
! 767: buffer_copy_string_buffer(s.rel_path, src->rel_path);
! 768: BUFFER_APPEND_SLASH(s.rel_path);
! 769: buffer_append_string(s.rel_path, de->d_name);
! 770:
! 771: buffer_copy_string_buffer(d.rel_path, dst->rel_path);
! 772: BUFFER_APPEND_SLASH(d.rel_path);
! 773: buffer_append_string(d.rel_path, de->d_name);
! 774:
! 775: if (-1 == stat(s.path->ptr, &st)) {
! 776: /* why ? */
! 777: } else if (S_ISDIR(st.st_mode)) {
! 778: /* a directory */
! 779: if (-1 == mkdir(d.path->ptr, WEBDAV_DIR_MODE) &&
! 780: errno != EEXIST) {
! 781: /* WTH ? */
! 782: } else {
! 783: #ifdef USE_PROPPATCH
! 784: sqlite3_stmt *stmt = p->conf.stmt_copy_uri;
! 785:
! 786: if (0 != (status = webdav_copy_dir(srv, con, p, &s, &d, overwrite))) {
! 787: break;
! 788: }
! 789: /* directory is copied, copy the properties too */
! 790:
! 791: if (stmt) {
! 792: sqlite3_reset(stmt);
! 793:
! 794: /* bind the values to the insert */
! 795: sqlite3_bind_text(stmt, 1,
! 796: dst->rel_path->ptr,
! 797: dst->rel_path->used - 1,
! 798: SQLITE_TRANSIENT);
! 799:
! 800: sqlite3_bind_text(stmt, 2,
! 801: src->rel_path->ptr,
! 802: src->rel_path->used - 1,
! 803: SQLITE_TRANSIENT);
! 804:
! 805: if (SQLITE_DONE != sqlite3_step(stmt)) {
! 806: /* */
! 807: }
! 808: }
! 809: #endif
! 810: }
! 811: } else if (S_ISREG(st.st_mode)) {
! 812: /* a plain file */
! 813: if (0 != (status = webdav_copy_file(srv, con, p, &s, &d, overwrite))) {
! 814: break;
! 815: }
! 816: }
! 817: }
! 818:
! 819: buffer_free(s.path);
! 820: buffer_free(s.rel_path);
! 821: buffer_free(d.path);
! 822: buffer_free(d.rel_path);
! 823:
! 824: closedir(srcdir);
! 825: }
! 826:
! 827: return status;
! 828: }
! 829:
! 830: static int webdav_get_live_property(server *srv, connection *con, plugin_data *p, physical *dst, char *prop_name, buffer *b) {
! 831: stat_cache_entry *sce = NULL;
! 832: int found = 0;
! 833:
! 834: UNUSED(p);
! 835:
! 836: if (HANDLER_ERROR != (stat_cache_get_entry(srv, con, dst->path, &sce))) {
! 837: char ctime_buf[] = "2005-08-18T07:27:16Z";
! 838: char mtime_buf[] = "Thu, 18 Aug 2005 07:27:16 GMT";
! 839: size_t k;
! 840:
! 841: if (0 == strcmp(prop_name, "resourcetype")) {
! 842: if (S_ISDIR(sce->st.st_mode)) {
! 843: buffer_append_string_len(b, CONST_STR_LEN("<D:resourcetype><D:collection/></D:resourcetype>"));
! 844: found = 1;
! 845: }
! 846: } else if (0 == strcmp(prop_name, "getcontenttype")) {
! 847: if (S_ISDIR(sce->st.st_mode)) {
! 848: buffer_append_string_len(b, CONST_STR_LEN("<D:getcontenttype>httpd/unix-directory</D:getcontenttype>"));
! 849: found = 1;
! 850: } else if(S_ISREG(sce->st.st_mode)) {
! 851: for (k = 0; k < con->conf.mimetypes->used; k++) {
! 852: data_string *ds = (data_string *)con->conf.mimetypes->data[k];
! 853:
! 854: if (ds->key->used == 0) continue;
! 855:
! 856: if (buffer_is_equal_right_len(dst->path, ds->key, ds->key->used - 1)) {
! 857: buffer_append_string_len(b,CONST_STR_LEN("<D:getcontenttype>"));
! 858: buffer_append_string_buffer(b, ds->value);
! 859: buffer_append_string_len(b, CONST_STR_LEN("</D:getcontenttype>"));
! 860: found = 1;
! 861:
! 862: break;
! 863: }
! 864: }
! 865: }
! 866: } else if (0 == strcmp(prop_name, "creationdate")) {
! 867: buffer_append_string_len(b, CONST_STR_LEN("<D:creationdate ns0:dt=\"dateTime.tz\">"));
! 868: strftime(ctime_buf, sizeof(ctime_buf), "%Y-%m-%dT%H:%M:%SZ", gmtime(&(sce->st.st_ctime)));
! 869: buffer_append_string(b, ctime_buf);
! 870: buffer_append_string_len(b, CONST_STR_LEN("</D:creationdate>"));
! 871: found = 1;
! 872: } else if (0 == strcmp(prop_name, "getlastmodified")) {
! 873: buffer_append_string_len(b,CONST_STR_LEN("<D:getlastmodified ns0:dt=\"dateTime.rfc1123\">"));
! 874: strftime(mtime_buf, sizeof(mtime_buf), "%a, %d %b %Y %H:%M:%S GMT", gmtime(&(sce->st.st_mtime)));
! 875: buffer_append_string(b, mtime_buf);
! 876: buffer_append_string_len(b, CONST_STR_LEN("</D:getlastmodified>"));
! 877: found = 1;
! 878: } else if (0 == strcmp(prop_name, "getcontentlength")) {
! 879: buffer_append_string_len(b,CONST_STR_LEN("<D:getcontentlength>"));
! 880: buffer_append_off_t(b, sce->st.st_size);
! 881: buffer_append_string_len(b, CONST_STR_LEN("</D:getcontentlength>"));
! 882: found = 1;
! 883: } else if (0 == strcmp(prop_name, "getcontentlanguage")) {
! 884: buffer_append_string_len(b,CONST_STR_LEN("<D:getcontentlanguage>"));
! 885: buffer_append_string_len(b, CONST_STR_LEN("en"));
! 886: buffer_append_string_len(b, CONST_STR_LEN("</D:getcontentlanguage>"));
! 887: found = 1;
! 888: }
! 889: }
! 890:
! 891: return found ? 0 : -1;
! 892: }
! 893:
! 894: static int webdav_get_property(server *srv, connection *con, plugin_data *p, physical *dst, char *prop_name, char *prop_ns, buffer *b) {
! 895: if (0 == strcmp(prop_ns, "DAV:")) {
! 896: /* a local 'live' property */
! 897: return webdav_get_live_property(srv, con, p, dst, prop_name, b);
! 898: } else {
! 899: int found = 0;
! 900: #ifdef USE_PROPPATCH
! 901: sqlite3_stmt *stmt = p->conf.stmt_select_prop;
! 902:
! 903: if (stmt) {
! 904: /* perhaps it is in sqlite3 */
! 905: sqlite3_reset(stmt);
! 906:
! 907: /* bind the values to the insert */
! 908:
! 909: sqlite3_bind_text(stmt, 1,
! 910: dst->rel_path->ptr,
! 911: dst->rel_path->used - 1,
! 912: SQLITE_TRANSIENT);
! 913: sqlite3_bind_text(stmt, 2,
! 914: prop_name,
! 915: strlen(prop_name),
! 916: SQLITE_TRANSIENT);
! 917: sqlite3_bind_text(stmt, 3,
! 918: prop_ns,
! 919: strlen(prop_ns),
! 920: SQLITE_TRANSIENT);
! 921:
! 922: /* it is the PK */
! 923: while (SQLITE_ROW == sqlite3_step(stmt)) {
! 924: /* there is a row for us, we only expect a single col 'value' */
! 925: webdav_gen_prop_tag(srv, con, prop_name, prop_ns, (char *)sqlite3_column_text(stmt, 0), b);
! 926: found = 1;
! 927: }
! 928: }
! 929: #endif
! 930: return found ? 0 : -1;
! 931: }
! 932:
! 933: /* not found */
! 934: return -1;
! 935: }
! 936:
! 937: typedef struct {
! 938: char *ns;
! 939: char *prop;
! 940: } webdav_property;
! 941:
! 942: static webdav_property live_properties[] = {
! 943: { "DAV:", "creationdate" },
! 944: { "DAV:", "displayname" },
! 945: { "DAV:", "getcontentlanguage" },
! 946: { "DAV:", "getcontentlength" },
! 947: { "DAV:", "getcontenttype" },
! 948: { "DAV:", "getetag" },
! 949: { "DAV:", "getlastmodified" },
! 950: { "DAV:", "resourcetype" },
! 951: { "DAV:", "lockdiscovery" },
! 952: { "DAV:", "source" },
! 953: { "DAV:", "supportedlock" },
! 954:
! 955: { NULL, NULL }
! 956: };
! 957:
! 958: typedef struct {
! 959: webdav_property **ptr;
! 960:
! 961: size_t used;
! 962: size_t size;
! 963: } webdav_properties;
! 964:
! 965: static int webdav_get_props(server *srv, connection *con, plugin_data *p, physical *dst, webdav_properties *props, buffer *b_200, buffer *b_404) {
! 966: size_t i;
! 967:
! 968: if (props) {
! 969: for (i = 0; i < props->used; i++) {
! 970: webdav_property *prop;
! 971:
! 972: prop = props->ptr[i];
! 973:
! 974: if (0 != webdav_get_property(srv, con, p,
! 975: dst, prop->prop, prop->ns, b_200)) {
! 976: webdav_gen_prop_tag(srv, con, prop->prop, prop->ns, NULL, b_404);
! 977: }
! 978: }
! 979: } else {
! 980: for (i = 0; live_properties[i].prop; i++) {
! 981: /* a local 'live' property */
! 982: webdav_get_live_property(srv, con, p, dst, live_properties[i].prop, b_200);
! 983: }
! 984: }
! 985:
! 986: return 0;
! 987: }
! 988:
! 989: #ifdef USE_PROPPATCH
! 990: static int webdav_parse_chunkqueue(server *srv, connection *con, plugin_data *p, chunkqueue *cq, xmlDoc **ret_xml) {
! 991: xmlParserCtxtPtr ctxt;
! 992: xmlDoc *xml;
! 993: int res;
! 994: int err;
! 995:
! 996: chunk *c;
! 997:
! 998: UNUSED(con);
! 999:
! 1000: /* read the chunks in to the XML document */
! 1001: ctxt = xmlCreatePushParserCtxt(NULL, NULL, NULL, 0, NULL);
! 1002:
! 1003: for (c = cq->first; cq->bytes_out != cq->bytes_in; c = cq->first) {
! 1004: size_t weWant = cq->bytes_out - cq->bytes_in;
! 1005: size_t weHave;
! 1006:
! 1007: switch(c->type) {
! 1008: case FILE_CHUNK:
! 1009: weHave = c->file.length - c->offset;
! 1010:
! 1011: if (weHave > weWant) weHave = weWant;
! 1012:
! 1013: /* xml chunks are always memory, mmap() is our friend */
! 1014: if (c->file.mmap.start == MAP_FAILED) {
! 1015: if (-1 == c->file.fd && /* open the file if not already open */
! 1016: -1 == (c->file.fd = open(c->file.name->ptr, O_RDONLY))) {
! 1017: log_error_write(srv, __FILE__, __LINE__, "ss", "open failed: ", strerror(errno));
! 1018:
! 1019: return -1;
! 1020: }
! 1021:
! 1022: if (MAP_FAILED == (c->file.mmap.start = mmap(0, c->file.length, PROT_READ, MAP_SHARED, c->file.fd, 0))) {
! 1023: log_error_write(srv, __FILE__, __LINE__, "ssbd", "mmap failed: ",
! 1024: strerror(errno), c->file.name, c->file.fd);
! 1025: close(c->file.fd);
! 1026: c->file.fd = -1;
! 1027:
! 1028: return -1;
! 1029: }
! 1030:
! 1031: close(c->file.fd);
! 1032: c->file.fd = -1;
! 1033:
! 1034: c->file.mmap.length = c->file.length;
! 1035:
! 1036: /* chunk_reset() or chunk_free() will cleanup for us */
! 1037: }
! 1038:
! 1039: if (XML_ERR_OK != (err = xmlParseChunk(ctxt, c->file.mmap.start + c->offset, weHave, 0))) {
! 1040: log_error_write(srv, __FILE__, __LINE__, "sodd", "xmlParseChunk failed at:", cq->bytes_out, weHave, err);
! 1041: }
! 1042:
! 1043: c->offset += weHave;
! 1044: cq->bytes_out += weHave;
! 1045:
! 1046: break;
! 1047: case MEM_CHUNK:
! 1048: /* append to the buffer */
! 1049: weHave = c->mem->used - 1 - c->offset;
! 1050:
! 1051: if (weHave > weWant) weHave = weWant;
! 1052:
! 1053: if (p->conf.log_xml) {
! 1054: log_error_write(srv, __FILE__, __LINE__, "ss", "XML-request-body:", c->mem->ptr + c->offset);
! 1055: }
! 1056:
! 1057: if (XML_ERR_OK != (err = xmlParseChunk(ctxt, c->mem->ptr + c->offset, weHave, 0))) {
! 1058: log_error_write(srv, __FILE__, __LINE__, "sodd", "xmlParseChunk failed at:", cq->bytes_out, weHave, err);
! 1059: }
! 1060:
! 1061: c->offset += weHave;
! 1062: cq->bytes_out += weHave;
! 1063:
! 1064: break;
! 1065: case UNUSED_CHUNK:
! 1066: break;
! 1067: }
! 1068: chunkqueue_remove_finished_chunks(cq);
! 1069: }
! 1070:
! 1071:
! 1072: switch ((err = xmlParseChunk(ctxt, 0, 0, 1))) {
! 1073: case XML_ERR_DOCUMENT_END:
! 1074: case XML_ERR_OK:
! 1075: break;
! 1076: default:
! 1077: log_error_write(srv, __FILE__, __LINE__, "sd", "xmlParseChunk failed at final packet:", err);
! 1078: break;
! 1079: }
! 1080:
! 1081: xml = ctxt->myDoc;
! 1082: res = ctxt->wellFormed;
! 1083: xmlFreeParserCtxt(ctxt);
! 1084:
! 1085: if (res == 0) {
! 1086: xmlFreeDoc(xml);
! 1087: } else {
! 1088: *ret_xml = xml;
! 1089: }
! 1090:
! 1091: return res;
! 1092: }
! 1093: #endif
! 1094:
! 1095: #ifdef USE_LOCKS
! 1096: static int webdav_lockdiscovery(server *srv, connection *con,
! 1097: buffer *locktoken, const char *lockscope, const char *locktype, int depth) {
! 1098:
! 1099: buffer *b;
! 1100:
! 1101: response_header_overwrite(srv, con, CONST_STR_LEN("Lock-Token"), CONST_BUF_LEN(locktoken));
! 1102:
! 1103: response_header_overwrite(srv, con,
! 1104: CONST_STR_LEN("Content-Type"),
! 1105: CONST_STR_LEN("text/xml; charset=\"utf-8\""));
! 1106:
! 1107: b = chunkqueue_get_append_buffer(con->write_queue);
! 1108:
! 1109: buffer_copy_string_len(b, CONST_STR_LEN("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"));
! 1110:
! 1111: buffer_append_string_len(b,CONST_STR_LEN("<D:prop xmlns:D=\"DAV:\" xmlns:ns0=\"urn:uuid:c2f41010-65b3-11d1-a29f-00aa00c14882/\">\n"));
! 1112: buffer_append_string_len(b,CONST_STR_LEN("<D:lockdiscovery>\n"));
! 1113: buffer_append_string_len(b,CONST_STR_LEN("<D:activelock>\n"));
! 1114:
! 1115: buffer_append_string_len(b,CONST_STR_LEN("<D:lockscope>"));
! 1116: buffer_append_string_len(b,CONST_STR_LEN("<D:"));
! 1117: buffer_append_string(b, lockscope);
! 1118: buffer_append_string_len(b, CONST_STR_LEN("/>"));
! 1119: buffer_append_string_len(b,CONST_STR_LEN("</D:lockscope>\n"));
! 1120:
! 1121: buffer_append_string_len(b,CONST_STR_LEN("<D:locktype>"));
! 1122: buffer_append_string_len(b,CONST_STR_LEN("<D:"));
! 1123: buffer_append_string(b, locktype);
! 1124: buffer_append_string_len(b, CONST_STR_LEN("/>"));
! 1125: buffer_append_string_len(b,CONST_STR_LEN("</D:locktype>\n"));
! 1126:
! 1127: buffer_append_string_len(b,CONST_STR_LEN("<D:depth>"));
! 1128: buffer_append_string(b, depth == 0 ? "0" : "infinity");
! 1129: buffer_append_string_len(b,CONST_STR_LEN("</D:depth>\n"));
! 1130:
! 1131: buffer_append_string_len(b,CONST_STR_LEN("<D:timeout>"));
! 1132: buffer_append_string_len(b, CONST_STR_LEN("Second-600"));
! 1133: buffer_append_string_len(b,CONST_STR_LEN("</D:timeout>\n"));
! 1134:
! 1135: buffer_append_string_len(b,CONST_STR_LEN("<D:owner>"));
! 1136: buffer_append_string_len(b,CONST_STR_LEN("</D:owner>\n"));
! 1137:
! 1138: buffer_append_string_len(b,CONST_STR_LEN("<D:locktoken>"));
! 1139: buffer_append_string_len(b, CONST_STR_LEN("<D:href>"));
! 1140: buffer_append_string_buffer(b, locktoken);
! 1141: buffer_append_string_len(b, CONST_STR_LEN("</D:href>"));
! 1142: buffer_append_string_len(b,CONST_STR_LEN("</D:locktoken>\n"));
! 1143:
! 1144: buffer_append_string_len(b,CONST_STR_LEN("</D:activelock>\n"));
! 1145: buffer_append_string_len(b,CONST_STR_LEN("</D:lockdiscovery>\n"));
! 1146: buffer_append_string_len(b,CONST_STR_LEN("</D:prop>\n"));
! 1147:
! 1148: return 0;
! 1149: }
! 1150: #endif
! 1151:
! 1152: /**
! 1153: * check if resource is having the right locks to access to resource
! 1154: *
! 1155: *
! 1156: *
! 1157: */
! 1158: static int webdav_has_lock(server *srv, connection *con, plugin_data *p, buffer *uri) {
! 1159: int has_lock = 1;
! 1160:
! 1161: #ifdef USE_LOCKS
! 1162: data_string *ds;
! 1163: UNUSED(srv);
! 1164:
! 1165: /**
! 1166: * This implementation is more fake than real
! 1167: * we need a parser for the If: header to really handle the full scope
! 1168: *
! 1169: * X-Litmus: locks: 11 (owner_modify)
! 1170: * If: <http://127.0.0.1:1025/dav/litmus/lockme> (<opaquelocktoken:2165478d-0611-49c4-be92-e790d68a38f1>)
! 1171: * - a tagged check:
! 1172: * if http://127.0.0.1:1025/dav/litmus/lockme is locked with
! 1173: * opaquelocktoken:2165478d-0611-49c4-be92-e790d68a38f1, go on
! 1174: *
! 1175: * X-Litmus: locks: 16 (fail_cond_put)
! 1176: * If: (<DAV:no-lock> ["-1622396671"])
! 1177: * - untagged:
! 1178: * go on if the resource has the etag [...] and the lock
! 1179: */
! 1180: if (NULL != (ds = (data_string *)array_get_element(con->request.headers, "If"))) {
! 1181: /* Ooh, ooh. A if tag, now the fun begins.
! 1182: *
! 1183: * this can only work with a real parser
! 1184: **/
! 1185: } else {
! 1186: /* we didn't provided a lock-token -> */
! 1187: /* if the resource is locked -> 423 */
! 1188:
! 1189: sqlite3_stmt *stmt = p->conf.stmt_read_lock_by_uri;
! 1190:
! 1191: sqlite3_reset(stmt);
! 1192:
! 1193: sqlite3_bind_text(stmt, 1,
! 1194: CONST_BUF_LEN(uri),
! 1195: SQLITE_TRANSIENT);
! 1196:
! 1197: while (SQLITE_ROW == sqlite3_step(stmt)) {
! 1198: has_lock = 0;
! 1199: }
! 1200: }
! 1201: #else
! 1202: UNUSED(srv);
! 1203: UNUSED(con);
! 1204: UNUSED(p);
! 1205: UNUSED(uri);
! 1206: #endif
! 1207:
! 1208: return has_lock;
! 1209: }
! 1210:
! 1211: URIHANDLER_FUNC(mod_webdav_subrequest_handler) {
! 1212: plugin_data *p = p_d;
! 1213: buffer *b;
! 1214: DIR *dir;
! 1215: data_string *ds;
! 1216: int depth = -1;
! 1217: struct stat st;
! 1218: buffer *prop_200;
! 1219: buffer *prop_404;
! 1220: webdav_properties *req_props;
! 1221: stat_cache_entry *sce = NULL;
! 1222:
! 1223: UNUSED(srv);
! 1224:
! 1225: if (!p->conf.enabled) return HANDLER_GO_ON;
! 1226: /* physical path is setup */
! 1227: if (con->physical.path->used == 0) return HANDLER_GO_ON;
! 1228:
! 1229: /* PROPFIND need them */
! 1230: if (NULL != (ds = (data_string *)array_get_element(con->request.headers, "Depth"))) {
! 1231: depth = strtol(ds->value->ptr, NULL, 10);
! 1232: }
! 1233:
! 1234: switch (con->request.http_method) {
! 1235: case HTTP_METHOD_PROPFIND:
! 1236: /* they want to know the properties of the directory */
! 1237: req_props = NULL;
! 1238:
! 1239: /* is there a content-body ? */
! 1240:
! 1241: switch (stat_cache_get_entry(srv, con, con->physical.path, &sce)) {
! 1242: case HANDLER_ERROR:
! 1243: if (errno == ENOENT) {
! 1244: con->http_status = 404;
! 1245: return HANDLER_FINISHED;
! 1246: }
! 1247: break;
! 1248: default:
! 1249: break;
! 1250: }
! 1251:
! 1252:
! 1253: #ifdef USE_PROPPATCH
! 1254: /* any special requests or just allprop ? */
! 1255: if (con->request.content_length) {
! 1256: xmlDocPtr xml;
! 1257:
! 1258: if (1 == webdav_parse_chunkqueue(srv, con, p, con->request_content_queue, &xml)) {
! 1259: xmlNode *rootnode = xmlDocGetRootElement(xml);
! 1260:
! 1261: assert(rootnode);
! 1262:
! 1263: if (0 == xmlStrcmp(rootnode->name, BAD_CAST "propfind")) {
! 1264: xmlNode *cmd;
! 1265:
! 1266: req_props = calloc(1, sizeof(*req_props));
! 1267:
! 1268: for (cmd = rootnode->children; cmd; cmd = cmd->next) {
! 1269:
! 1270: if (0 == xmlStrcmp(cmd->name, BAD_CAST "prop")) {
! 1271: /* get prop by name */
! 1272: xmlNode *prop;
! 1273:
! 1274: for (prop = cmd->children; prop; prop = prop->next) {
! 1275: if (prop->type == XML_TEXT_NODE) continue; /* ignore WS */
! 1276:
! 1277: if (prop->ns &&
! 1278: (0 == xmlStrcmp(prop->ns->href, BAD_CAST "")) &&
! 1279: (0 != xmlStrcmp(prop->ns->prefix, BAD_CAST ""))) {
! 1280: size_t i;
! 1281: log_error_write(srv, __FILE__, __LINE__, "ss",
! 1282: "no name space for:",
! 1283: prop->name);
! 1284:
! 1285: xmlFreeDoc(xml);
! 1286:
! 1287: for (i = 0; i < req_props->used; i++) {
! 1288: free(req_props->ptr[i]->ns);
! 1289: free(req_props->ptr[i]->prop);
! 1290: free(req_props->ptr[i]);
! 1291: }
! 1292: free(req_props->ptr);
! 1293: free(req_props);
! 1294:
! 1295: con->http_status = 400;
! 1296: return HANDLER_FINISHED;
! 1297: }
! 1298:
! 1299: /* add property to requested list */
! 1300: if (req_props->size == 0) {
! 1301: req_props->size = 16;
! 1302: req_props->ptr = malloc(sizeof(*(req_props->ptr)) * req_props->size);
! 1303: } else if (req_props->used == req_props->size) {
! 1304: req_props->size += 16;
! 1305: req_props->ptr = realloc(req_props->ptr, sizeof(*(req_props->ptr)) * req_props->size);
! 1306: }
! 1307:
! 1308: req_props->ptr[req_props->used] = malloc(sizeof(webdav_property));
! 1309: req_props->ptr[req_props->used]->ns = (char *)xmlStrdup(prop->ns ? prop->ns->href : (xmlChar *)"");
! 1310: req_props->ptr[req_props->used]->prop = (char *)xmlStrdup(prop->name);
! 1311: req_props->used++;
! 1312: }
! 1313: } else if (0 == xmlStrcmp(cmd->name, BAD_CAST "propname")) {
! 1314: sqlite3_stmt *stmt = p->conf.stmt_select_propnames;
! 1315:
! 1316: if (stmt) {
! 1317: /* get all property names (EMPTY) */
! 1318: sqlite3_reset(stmt);
! 1319: /* bind the values to the insert */
! 1320:
! 1321: sqlite3_bind_text(stmt, 1,
! 1322: con->uri.path->ptr,
! 1323: con->uri.path->used - 1,
! 1324: SQLITE_TRANSIENT);
! 1325:
! 1326: if (SQLITE_DONE != sqlite3_step(stmt)) {
! 1327: }
! 1328: }
! 1329: } else if (0 == xmlStrcmp(cmd->name, BAD_CAST "allprop")) {
! 1330: /* get all properties (EMPTY) */
! 1331: }
! 1332: }
! 1333: }
! 1334:
! 1335: xmlFreeDoc(xml);
! 1336: } else {
! 1337: con->http_status = 400;
! 1338: return HANDLER_FINISHED;
! 1339: }
! 1340: }
! 1341: #endif
! 1342: con->http_status = 207;
! 1343:
! 1344: response_header_overwrite(srv, con, CONST_STR_LEN("Content-Type"), CONST_STR_LEN("text/xml; charset=\"utf-8\""));
! 1345:
! 1346: b = chunkqueue_get_append_buffer(con->write_queue);
! 1347:
! 1348: buffer_copy_string_len(b, CONST_STR_LEN("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"));
! 1349:
! 1350: buffer_append_string_len(b,CONST_STR_LEN("<D:multistatus xmlns:D=\"DAV:\" xmlns:ns0=\"urn:uuid:c2f41010-65b3-11d1-a29f-00aa00c14882/\">\n"));
! 1351:
! 1352: /* allprop */
! 1353:
! 1354: prop_200 = buffer_init();
! 1355: prop_404 = buffer_init();
! 1356:
! 1357: switch(depth) {
! 1358: case 0:
! 1359: /* Depth: 0 */
! 1360: webdav_get_props(srv, con, p, &(con->physical), req_props, prop_200, prop_404);
! 1361:
! 1362: buffer_append_string_len(b,CONST_STR_LEN("<D:response>\n"));
! 1363: buffer_append_string_len(b,CONST_STR_LEN("<D:href>"));
! 1364: buffer_append_string_buffer(b, con->uri.scheme);
! 1365: buffer_append_string_len(b,CONST_STR_LEN("://"));
! 1366: buffer_append_string_buffer(b, con->uri.authority);
! 1367: buffer_append_string_encoded(b, CONST_BUF_LEN(con->uri.path), ENCODING_REL_URI);
! 1368: buffer_append_string_len(b,CONST_STR_LEN("</D:href>\n"));
! 1369:
! 1370: if (!buffer_is_empty(prop_200)) {
! 1371: buffer_append_string_len(b,CONST_STR_LEN("<D:propstat>\n"));
! 1372: buffer_append_string_len(b,CONST_STR_LEN("<D:prop>\n"));
! 1373:
! 1374: buffer_append_string_buffer(b, prop_200);
! 1375:
! 1376: buffer_append_string_len(b,CONST_STR_LEN("</D:prop>\n"));
! 1377:
! 1378: buffer_append_string_len(b,CONST_STR_LEN("<D:status>HTTP/1.1 200 OK</D:status>\n"));
! 1379:
! 1380: buffer_append_string_len(b,CONST_STR_LEN("</D:propstat>\n"));
! 1381: }
! 1382: if (!buffer_is_empty(prop_404)) {
! 1383: buffer_append_string_len(b,CONST_STR_LEN("<D:propstat>\n"));
! 1384: buffer_append_string_len(b,CONST_STR_LEN("<D:prop>\n"));
! 1385:
! 1386: buffer_append_string_buffer(b, prop_404);
! 1387:
! 1388: buffer_append_string_len(b,CONST_STR_LEN("</D:prop>\n"));
! 1389:
! 1390: buffer_append_string_len(b,CONST_STR_LEN("<D:status>HTTP/1.1 404 Not Found</D:status>\n"));
! 1391:
! 1392: buffer_append_string_len(b,CONST_STR_LEN("</D:propstat>\n"));
! 1393: }
! 1394:
! 1395: buffer_append_string_len(b,CONST_STR_LEN("</D:response>\n"));
! 1396:
! 1397: break;
! 1398: case 1:
! 1399: if (NULL != (dir = opendir(con->physical.path->ptr))) {
! 1400: struct dirent *de;
! 1401: physical d;
! 1402: physical *dst = &(con->physical);
! 1403:
! 1404: d.path = buffer_init();
! 1405: d.rel_path = buffer_init();
! 1406:
! 1407: while(NULL != (de = readdir(dir))) {
! 1408: if (de->d_name[0] == '.' && de->d_name[1] == '.' && de->d_name[2] == '\0') {
! 1409: continue;
! 1410: /* ignore the parent dir */
! 1411: }
! 1412:
! 1413: buffer_copy_string_buffer(d.path, dst->path);
! 1414: BUFFER_APPEND_SLASH(d.path);
! 1415:
! 1416: buffer_copy_string_buffer(d.rel_path, dst->rel_path);
! 1417: BUFFER_APPEND_SLASH(d.rel_path);
! 1418:
! 1419: if (de->d_name[0] == '.' && de->d_name[1] == '\0') {
! 1420: /* don't append the . */
! 1421: } else {
! 1422: buffer_append_string(d.path, de->d_name);
! 1423: buffer_append_string(d.rel_path, de->d_name);
! 1424: }
! 1425:
! 1426: buffer_reset(prop_200);
! 1427: buffer_reset(prop_404);
! 1428:
! 1429: webdav_get_props(srv, con, p, &d, req_props, prop_200, prop_404);
! 1430:
! 1431: buffer_append_string_len(b,CONST_STR_LEN("<D:response>\n"));
! 1432: buffer_append_string_len(b,CONST_STR_LEN("<D:href>"));
! 1433: buffer_append_string_buffer(b, con->uri.scheme);
! 1434: buffer_append_string_len(b,CONST_STR_LEN("://"));
! 1435: buffer_append_string_buffer(b, con->uri.authority);
! 1436: buffer_append_string_encoded(b, CONST_BUF_LEN(d.rel_path), ENCODING_REL_URI);
! 1437: buffer_append_string_len(b,CONST_STR_LEN("</D:href>\n"));
! 1438:
! 1439: if (!buffer_is_empty(prop_200)) {
! 1440: buffer_append_string_len(b,CONST_STR_LEN("<D:propstat>\n"));
! 1441: buffer_append_string_len(b,CONST_STR_LEN("<D:prop>\n"));
! 1442:
! 1443: buffer_append_string_buffer(b, prop_200);
! 1444:
! 1445: buffer_append_string_len(b,CONST_STR_LEN("</D:prop>\n"));
! 1446:
! 1447: buffer_append_string_len(b,CONST_STR_LEN("<D:status>HTTP/1.1 200 OK</D:status>\n"));
! 1448:
! 1449: buffer_append_string_len(b,CONST_STR_LEN("</D:propstat>\n"));
! 1450: }
! 1451: if (!buffer_is_empty(prop_404)) {
! 1452: buffer_append_string_len(b,CONST_STR_LEN("<D:propstat>\n"));
! 1453: buffer_append_string_len(b,CONST_STR_LEN("<D:prop>\n"));
! 1454:
! 1455: buffer_append_string_buffer(b, prop_404);
! 1456:
! 1457: buffer_append_string_len(b,CONST_STR_LEN("</D:prop>\n"));
! 1458:
! 1459: buffer_append_string_len(b,CONST_STR_LEN("<D:status>HTTP/1.1 404 Not Found</D:status>\n"));
! 1460:
! 1461: buffer_append_string_len(b,CONST_STR_LEN("</D:propstat>\n"));
! 1462: }
! 1463:
! 1464: buffer_append_string_len(b,CONST_STR_LEN("</D:response>\n"));
! 1465: }
! 1466: closedir(dir);
! 1467: buffer_free(d.path);
! 1468: buffer_free(d.rel_path);
! 1469: }
! 1470: break;
! 1471: }
! 1472:
! 1473: if (req_props) {
! 1474: size_t i;
! 1475: for (i = 0; i < req_props->used; i++) {
! 1476: free(req_props->ptr[i]->ns);
! 1477: free(req_props->ptr[i]->prop);
! 1478: free(req_props->ptr[i]);
! 1479: }
! 1480: free(req_props->ptr);
! 1481: free(req_props);
! 1482: }
! 1483:
! 1484: buffer_free(prop_200);
! 1485: buffer_free(prop_404);
! 1486:
! 1487: buffer_append_string_len(b,CONST_STR_LEN("</D:multistatus>\n"));
! 1488:
! 1489: if (p->conf.log_xml) {
! 1490: log_error_write(srv, __FILE__, __LINE__, "sb", "XML-response-body:", b);
! 1491: }
! 1492: con->file_finished = 1;
! 1493:
! 1494: return HANDLER_FINISHED;
! 1495: case HTTP_METHOD_MKCOL:
! 1496: if (p->conf.is_readonly) {
! 1497: con->http_status = 403;
! 1498: return HANDLER_FINISHED;
! 1499: }
! 1500:
! 1501: if (con->request.content_length != 0) {
! 1502: /* we don't support MKCOL with a body */
! 1503: con->http_status = 415;
! 1504:
! 1505: return HANDLER_FINISHED;
! 1506: }
! 1507:
! 1508: /* let's create the directory */
! 1509:
! 1510: if (-1 == mkdir(con->physical.path->ptr, WEBDAV_DIR_MODE)) {
! 1511: switch(errno) {
! 1512: case EPERM:
! 1513: con->http_status = 403;
! 1514: break;
! 1515: case ENOENT:
! 1516: case ENOTDIR:
! 1517: con->http_status = 409;
! 1518: break;
! 1519: case EEXIST:
! 1520: default:
! 1521: con->http_status = 405; /* not allowed */
! 1522: break;
! 1523: }
! 1524: } else {
! 1525: con->http_status = 201;
! 1526: con->file_finished = 1;
! 1527: }
! 1528:
! 1529: return HANDLER_FINISHED;
! 1530: case HTTP_METHOD_DELETE:
! 1531: if (p->conf.is_readonly) {
! 1532: con->http_status = 403;
! 1533: return HANDLER_FINISHED;
! 1534: }
! 1535:
! 1536: /* does the client have a lock for this connection ? */
! 1537: if (!webdav_has_lock(srv, con, p, con->uri.path)) {
! 1538: con->http_status = 423;
! 1539: return HANDLER_FINISHED;
! 1540: }
! 1541:
! 1542: /* stat and unlink afterwards */
! 1543: if (-1 == stat(con->physical.path->ptr, &st)) {
! 1544: /* don't about it yet, unlink will fail too */
! 1545: switch(errno) {
! 1546: case ENOENT:
! 1547: con->http_status = 404;
! 1548: break;
! 1549: default:
! 1550: con->http_status = 403;
! 1551: break;
! 1552: }
! 1553: } else if (S_ISDIR(st.st_mode)) {
! 1554: buffer *multi_status_resp = buffer_init();
! 1555:
! 1556: if (webdav_delete_dir(srv, con, p, &(con->physical), multi_status_resp)) {
! 1557: /* we got an error somewhere in between, build a 207 */
! 1558: response_header_overwrite(srv, con, CONST_STR_LEN("Content-Type"), CONST_STR_LEN("text/xml; charset=\"utf-8\""));
! 1559:
! 1560: b = chunkqueue_get_append_buffer(con->write_queue);
! 1561:
! 1562: buffer_copy_string_len(b, CONST_STR_LEN("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"));
! 1563:
! 1564: buffer_append_string_len(b,CONST_STR_LEN("<D:multistatus xmlns:D=\"DAV:\">\n"));
! 1565:
! 1566: buffer_append_string_buffer(b, multi_status_resp);
! 1567:
! 1568: buffer_append_string_len(b,CONST_STR_LEN("</D:multistatus>\n"));
! 1569:
! 1570: if (p->conf.log_xml) {
! 1571: log_error_write(srv, __FILE__, __LINE__, "sb", "XML-response-body:", b);
! 1572: }
! 1573:
! 1574: con->http_status = 207;
! 1575: con->file_finished = 1;
! 1576: } else {
! 1577: /* everything went fine, remove the directory */
! 1578:
! 1579: if (-1 == rmdir(con->physical.path->ptr)) {
! 1580: switch(errno) {
! 1581: case ENOENT:
! 1582: con->http_status = 404;
! 1583: break;
! 1584: default:
! 1585: con->http_status = 501;
! 1586: break;
! 1587: }
! 1588: } else {
! 1589: con->http_status = 204;
! 1590: }
! 1591: }
! 1592:
! 1593: buffer_free(multi_status_resp);
! 1594: } else if (-1 == unlink(con->physical.path->ptr)) {
! 1595: switch(errno) {
! 1596: case EPERM:
! 1597: con->http_status = 403;
! 1598: break;
! 1599: case ENOENT:
! 1600: con->http_status = 404;
! 1601: break;
! 1602: default:
! 1603: con->http_status = 501;
! 1604: break;
! 1605: }
! 1606: } else {
! 1607: con->http_status = 204;
! 1608: }
! 1609: return HANDLER_FINISHED;
! 1610: case HTTP_METHOD_PUT: {
! 1611: int fd;
! 1612: chunkqueue *cq = con->request_content_queue;
! 1613: chunk *c;
! 1614: data_string *ds_range;
! 1615:
! 1616: if (p->conf.is_readonly) {
! 1617: con->http_status = 403;
! 1618: return HANDLER_FINISHED;
! 1619: }
! 1620:
! 1621: /* is a exclusive lock set on the source */
! 1622: if (!webdav_has_lock(srv, con, p, con->uri.path)) {
! 1623: con->http_status = 423;
! 1624: return HANDLER_FINISHED;
! 1625: }
! 1626:
! 1627:
! 1628: assert(chunkqueue_length(cq) == (off_t)con->request.content_length);
! 1629:
! 1630: /* RFC2616 Section 9.6 PUT requires us to send 501 on all Content-* we don't support
! 1631: * - most important Content-Range
! 1632: *
! 1633: *
! 1634: * Example: Content-Range: bytes 100-1037/1038 */
! 1635:
! 1636: if (NULL != (ds_range = (data_string *)array_get_element(con->request.headers, "Content-Range"))) {
! 1637: const char *num = ds_range->value->ptr;
! 1638: off_t offset;
! 1639: char *err = NULL;
! 1640:
! 1641: if (0 != strncmp(num, "bytes ", 6)) {
! 1642: con->http_status = 501; /* not implemented */
! 1643:
! 1644: return HANDLER_FINISHED;
! 1645: }
! 1646:
! 1647: /* we only support <num>- ... */
! 1648:
! 1649: num += 6;
! 1650:
! 1651: /* skip WS */
! 1652: while (*num == ' ' || *num == '\t') num++;
! 1653:
! 1654: if (*num == '\0') {
! 1655: con->http_status = 501; /* not implemented */
! 1656:
! 1657: return HANDLER_FINISHED;
! 1658: }
! 1659:
! 1660: offset = strtoll(num, &err, 10);
! 1661:
! 1662: if (*err != '-' || offset < 0) {
! 1663: con->http_status = 501; /* not implemented */
! 1664:
! 1665: return HANDLER_FINISHED;
! 1666: }
! 1667:
! 1668: if (-1 == (fd = open(con->physical.path->ptr, O_WRONLY, WEBDAV_FILE_MODE))) {
! 1669: switch (errno) {
! 1670: case ENOENT:
! 1671: con->http_status = 404; /* not found */
! 1672: break;
! 1673: default:
! 1674: con->http_status = 403; /* not found */
! 1675: break;
! 1676: }
! 1677: return HANDLER_FINISHED;
! 1678: }
! 1679:
! 1680: if (-1 == lseek(fd, offset, SEEK_SET)) {
! 1681: con->http_status = 501; /* not implemented */
! 1682:
! 1683: close(fd);
! 1684:
! 1685: return HANDLER_FINISHED;
! 1686: }
! 1687: con->http_status = 200; /* modified */
! 1688: } else {
! 1689: /* take what we have in the request-body and write it to a file */
! 1690:
! 1691: /* if the file doesn't exist, create it */
! 1692: if (-1 == (fd = open(con->physical.path->ptr, O_WRONLY|O_TRUNC, WEBDAV_FILE_MODE))) {
! 1693: if (errno == ENOENT &&
! 1694: -1 == (fd = open(con->physical.path->ptr, O_WRONLY|O_CREAT|O_TRUNC|O_EXCL, WEBDAV_FILE_MODE))) {
! 1695: /* we can't open the file */
! 1696: con->http_status = 403;
! 1697:
! 1698: return HANDLER_FINISHED;
! 1699: } else {
! 1700: con->http_status = 201; /* created */
! 1701: }
! 1702: } else {
! 1703: con->http_status = 200; /* modified */
! 1704: }
! 1705: }
! 1706:
! 1707: con->file_finished = 1;
! 1708:
! 1709: for (c = cq->first; c; c = cq->first) {
! 1710: int r = 0;
! 1711:
! 1712: /* copy all chunks */
! 1713: switch(c->type) {
! 1714: case FILE_CHUNK:
! 1715:
! 1716: if (c->file.mmap.start == MAP_FAILED) {
! 1717: if (-1 == c->file.fd && /* open the file if not already open */
! 1718: -1 == (c->file.fd = open(c->file.name->ptr, O_RDONLY))) {
! 1719: log_error_write(srv, __FILE__, __LINE__, "ss", "open failed: ", strerror(errno));
! 1720:
! 1721: return HANDLER_ERROR;
! 1722: }
! 1723:
! 1724: if (MAP_FAILED == (c->file.mmap.start = mmap(NULL, c->file.length, PROT_READ, MAP_SHARED, c->file.fd, 0))) {
! 1725: log_error_write(srv, __FILE__, __LINE__, "ssbd", "mmap failed: ",
! 1726: strerror(errno), c->file.name, c->file.fd);
! 1727: close(c->file.fd);
! 1728: c->file.fd = -1;
! 1729:
! 1730: return HANDLER_ERROR;
! 1731: }
! 1732:
! 1733: c->file.mmap.length = c->file.length;
! 1734:
! 1735: close(c->file.fd);
! 1736: c->file.fd = -1;
! 1737:
! 1738: /* chunk_reset() or chunk_free() will cleanup for us */
! 1739: }
! 1740:
! 1741: if ((r = write(fd, c->file.mmap.start + c->offset, c->file.length - c->offset)) < 0) {
! 1742: switch(errno) {
! 1743: case ENOSPC:
! 1744: con->http_status = 507;
! 1745:
! 1746: break;
! 1747: default:
! 1748: con->http_status = 403;
! 1749: break;
! 1750: }
! 1751: }
! 1752: break;
! 1753: case MEM_CHUNK:
! 1754: if ((r = write(fd, c->mem->ptr + c->offset, c->mem->used - c->offset - 1)) < 0) {
! 1755: switch(errno) {
! 1756: case ENOSPC:
! 1757: con->http_status = 507;
! 1758:
! 1759: break;
! 1760: default:
! 1761: con->http_status = 403;
! 1762: break;
! 1763: }
! 1764: }
! 1765: break;
! 1766: case UNUSED_CHUNK:
! 1767: break;
! 1768: }
! 1769:
! 1770: if (r > 0) {
! 1771: c->offset += r;
! 1772: cq->bytes_out += r;
! 1773: } else {
! 1774: break;
! 1775: }
! 1776: chunkqueue_remove_finished_chunks(cq);
! 1777: }
! 1778: close(fd);
! 1779:
! 1780: return HANDLER_FINISHED;
! 1781: }
! 1782: case HTTP_METHOD_MOVE:
! 1783: case HTTP_METHOD_COPY: {
! 1784: buffer *destination = NULL;
! 1785: char *sep, *sep2, *start;
! 1786: int overwrite = 1;
! 1787:
! 1788: if (p->conf.is_readonly) {
! 1789: con->http_status = 403;
! 1790: return HANDLER_FINISHED;
! 1791: }
! 1792:
! 1793: /* is a exclusive lock set on the source */
! 1794: if (con->request.http_method == HTTP_METHOD_MOVE) {
! 1795: if (!webdav_has_lock(srv, con, p, con->uri.path)) {
! 1796: con->http_status = 423;
! 1797: return HANDLER_FINISHED;
! 1798: }
! 1799: }
! 1800:
! 1801: if (NULL != (ds = (data_string *)array_get_element(con->request.headers, "Destination"))) {
! 1802: destination = ds->value;
! 1803: } else {
! 1804: con->http_status = 400;
! 1805: return HANDLER_FINISHED;
! 1806: }
! 1807:
! 1808: if (NULL != (ds = (data_string *)array_get_element(con->request.headers, "Overwrite"))) {
! 1809: if (ds->value->used != 2 ||
! 1810: (ds->value->ptr[0] != 'F' &&
! 1811: ds->value->ptr[0] != 'T') ) {
! 1812: con->http_status = 400;
! 1813: return HANDLER_FINISHED;
! 1814: }
! 1815: overwrite = (ds->value->ptr[0] == 'F' ? 0 : 1);
! 1816: }
! 1817: /* let's parse the Destination
! 1818: *
! 1819: * http://127.0.0.1:1025/dav/litmus/copydest
! 1820: *
! 1821: * - host has to be the same as the Host: header we got
! 1822: * - we have to stay inside the document root
! 1823: * - the query string is thrown away
! 1824: * */
! 1825:
! 1826: buffer_reset(p->uri.scheme);
! 1827: buffer_reset(p->uri.path_raw);
! 1828: buffer_reset(p->uri.authority);
! 1829:
! 1830: start = destination->ptr;
! 1831:
! 1832: if (NULL == (sep = strstr(start, "://"))) {
! 1833: con->http_status = 400;
! 1834: return HANDLER_FINISHED;
! 1835: }
! 1836: buffer_copy_string_len(p->uri.scheme, start, sep - start);
! 1837:
! 1838: start = sep + 3;
! 1839:
! 1840: if (NULL == (sep = strchr(start, '/'))) {
! 1841: con->http_status = 400;
! 1842: return HANDLER_FINISHED;
! 1843: }
! 1844: if (NULL != (sep2 = memchr(start, '@', sep - start))) {
! 1845: /* skip login information */
! 1846: start = sep2 + 1;
! 1847: }
! 1848: buffer_copy_string_len(p->uri.authority, start, sep - start);
! 1849:
! 1850: start = sep + 1;
! 1851:
! 1852: if (NULL == (sep = strchr(start, '?'))) {
! 1853: /* no query string, good */
! 1854: buffer_copy_string(p->uri.path_raw, start);
! 1855: } else {
! 1856: buffer_copy_string_len(p->uri.path_raw, start, sep - start);
! 1857: }
! 1858:
! 1859: if (!buffer_is_equal(p->uri.authority, con->uri.authority)) {
! 1860: /* not the same host */
! 1861: con->http_status = 502;
! 1862: return HANDLER_FINISHED;
! 1863: }
! 1864:
! 1865: buffer_copy_string_buffer(p->tmp_buf, p->uri.path_raw);
! 1866: buffer_urldecode_path(p->tmp_buf);
! 1867: buffer_path_simplify(p->uri.path, p->tmp_buf);
! 1868:
! 1869: /* we now have a URI which is clean. transform it into a physical path */
! 1870: buffer_copy_string_buffer(p->physical.doc_root, con->physical.doc_root);
! 1871: buffer_copy_string_buffer(p->physical.rel_path, p->uri.path);
! 1872:
! 1873: if (con->conf.force_lowercase_filenames) {
! 1874: buffer_to_lower(p->physical.rel_path);
! 1875: }
! 1876:
! 1877: buffer_copy_string_buffer(p->physical.path, p->physical.doc_root);
! 1878: BUFFER_APPEND_SLASH(p->physical.path);
! 1879: buffer_copy_string_buffer(p->physical.basedir, p->physical.path);
! 1880:
! 1881: /* don't add a second / */
! 1882: if (p->physical.rel_path->ptr[0] == '/') {
! 1883: buffer_append_string_len(p->physical.path, p->physical.rel_path->ptr + 1, p->physical.rel_path->used - 2);
! 1884: } else {
! 1885: buffer_append_string_buffer(p->physical.path, p->physical.rel_path);
! 1886: }
! 1887:
! 1888: /* let's see if the source is a directory
! 1889: * if yes, we fail with 501 */
! 1890:
! 1891: if (-1 == stat(con->physical.path->ptr, &st)) {
! 1892: /* don't about it yet, unlink will fail too */
! 1893: switch(errno) {
! 1894: case ENOENT:
! 1895: con->http_status = 404;
! 1896: break;
! 1897: default:
! 1898: con->http_status = 403;
! 1899: break;
! 1900: }
! 1901: } else if (S_ISDIR(st.st_mode)) {
! 1902: int r;
! 1903: /* src is a directory */
! 1904:
! 1905: if (-1 == stat(p->physical.path->ptr, &st)) {
! 1906: if (-1 == mkdir(p->physical.path->ptr, WEBDAV_DIR_MODE)) {
! 1907: con->http_status = 403;
! 1908: return HANDLER_FINISHED;
! 1909: }
! 1910: } else if (!S_ISDIR(st.st_mode)) {
! 1911: if (overwrite == 0) {
! 1912: /* copying into a non-dir ? */
! 1913: con->http_status = 409;
! 1914: return HANDLER_FINISHED;
! 1915: } else {
! 1916: unlink(p->physical.path->ptr);
! 1917: if (-1 == mkdir(p->physical.path->ptr, WEBDAV_DIR_MODE)) {
! 1918: con->http_status = 403;
! 1919: return HANDLER_FINISHED;
! 1920: }
! 1921: }
! 1922: }
! 1923:
! 1924: /* copy the content of src to dest */
! 1925: if (0 != (r = webdav_copy_dir(srv, con, p, &(con->physical), &(p->physical), overwrite))) {
! 1926: con->http_status = r;
! 1927: return HANDLER_FINISHED;
! 1928: }
! 1929: if (con->request.http_method == HTTP_METHOD_MOVE) {
! 1930: b = buffer_init();
! 1931: webdav_delete_dir(srv, con, p, &(con->physical), b); /* content */
! 1932: buffer_free(b);
! 1933:
! 1934: rmdir(con->physical.path->ptr);
! 1935: }
! 1936: con->http_status = 201;
! 1937: con->file_finished = 1;
! 1938: } else {
! 1939: /* it is just a file, good */
! 1940: int r;
! 1941:
! 1942: /* does the client have a lock for this connection ? */
! 1943: if (!webdav_has_lock(srv, con, p, p->uri.path)) {
! 1944: con->http_status = 423;
! 1945: return HANDLER_FINISHED;
! 1946: }
! 1947:
! 1948: /* destination exists */
! 1949: if (0 == (r = stat(p->physical.path->ptr, &st))) {
! 1950: if (S_ISDIR(st.st_mode)) {
! 1951: /* file to dir/
! 1952: * append basename to physical path */
! 1953:
! 1954: if (NULL != (sep = strrchr(con->physical.path->ptr, '/'))) {
! 1955: buffer_append_string(p->physical.path, sep);
! 1956: r = stat(p->physical.path->ptr, &st);
! 1957: }
! 1958: }
! 1959: }
! 1960:
! 1961: if (-1 == r) {
! 1962: con->http_status = 201; /* we will create a new one */
! 1963: con->file_finished = 1;
! 1964:
! 1965: switch(errno) {
! 1966: case ENOTDIR:
! 1967: con->http_status = 409;
! 1968: return HANDLER_FINISHED;
! 1969: }
! 1970: } else if (overwrite == 0) {
! 1971: /* destination exists, but overwrite is not set */
! 1972: con->http_status = 412;
! 1973: return HANDLER_FINISHED;
! 1974: } else {
! 1975: con->http_status = 204; /* resource already existed */
! 1976: }
! 1977:
! 1978: if (con->request.http_method == HTTP_METHOD_MOVE) {
! 1979: /* try a rename */
! 1980:
! 1981: if (0 == rename(con->physical.path->ptr, p->physical.path->ptr)) {
! 1982: #ifdef USE_PROPPATCH
! 1983: sqlite3_stmt *stmt;
! 1984:
! 1985: stmt = p->conf.stmt_delete_uri;
! 1986: if (stmt) {
! 1987:
! 1988: sqlite3_reset(stmt);
! 1989:
! 1990: /* bind the values to the insert */
! 1991: sqlite3_bind_text(stmt, 1,
! 1992: con->uri.path->ptr,
! 1993: con->uri.path->used - 1,
! 1994: SQLITE_TRANSIENT);
! 1995:
! 1996: if (SQLITE_DONE != sqlite3_step(stmt)) {
! 1997: log_error_write(srv, __FILE__, __LINE__, "ss", "sql-move(delete old) failed:", sqlite3_errmsg(p->conf.sql));
! 1998: }
! 1999: }
! 2000:
! 2001: stmt = p->conf.stmt_move_uri;
! 2002: if (stmt) {
! 2003:
! 2004: sqlite3_reset(stmt);
! 2005:
! 2006: /* bind the values to the insert */
! 2007: sqlite3_bind_text(stmt, 1,
! 2008: p->uri.path->ptr,
! 2009: p->uri.path->used - 1,
! 2010: SQLITE_TRANSIENT);
! 2011:
! 2012: sqlite3_bind_text(stmt, 2,
! 2013: con->uri.path->ptr,
! 2014: con->uri.path->used - 1,
! 2015: SQLITE_TRANSIENT);
! 2016:
! 2017: if (SQLITE_DONE != sqlite3_step(stmt)) {
! 2018: log_error_write(srv, __FILE__, __LINE__, "ss", "sql-move failed:", sqlite3_errmsg(p->conf.sql));
! 2019: }
! 2020: }
! 2021: #endif
! 2022: return HANDLER_FINISHED;
! 2023: }
! 2024:
! 2025: /* rename failed, fall back to COPY + DELETE */
! 2026: }
! 2027:
! 2028: if (0 != (r = webdav_copy_file(srv, con, p, &(con->physical), &(p->physical), overwrite))) {
! 2029: con->http_status = r;
! 2030:
! 2031: return HANDLER_FINISHED;
! 2032: }
! 2033:
! 2034: if (con->request.http_method == HTTP_METHOD_MOVE) {
! 2035: b = buffer_init();
! 2036: webdav_delete_file(srv, con, p, &(con->physical), b);
! 2037: buffer_free(b);
! 2038: }
! 2039: }
! 2040:
! 2041: return HANDLER_FINISHED;
! 2042: }
! 2043: case HTTP_METHOD_PROPPATCH:
! 2044: if (p->conf.is_readonly) {
! 2045: con->http_status = 403;
! 2046: return HANDLER_FINISHED;
! 2047: }
! 2048:
! 2049: if (!webdav_has_lock(srv, con, p, con->uri.path)) {
! 2050: con->http_status = 423;
! 2051: return HANDLER_FINISHED;
! 2052: }
! 2053:
! 2054: /* check if destination exists */
! 2055: if (-1 == stat(con->physical.path->ptr, &st)) {
! 2056: switch(errno) {
! 2057: case ENOENT:
! 2058: con->http_status = 404;
! 2059: break;
! 2060: }
! 2061: }
! 2062:
! 2063: #ifdef USE_PROPPATCH
! 2064: if (con->request.content_length) {
! 2065: xmlDocPtr xml;
! 2066:
! 2067: if (1 == webdav_parse_chunkqueue(srv, con, p, con->request_content_queue, &xml)) {
! 2068: xmlNode *rootnode = xmlDocGetRootElement(xml);
! 2069:
! 2070: if (0 == xmlStrcmp(rootnode->name, BAD_CAST "propertyupdate")) {
! 2071: xmlNode *cmd;
! 2072: char *err = NULL;
! 2073: int empty_ns = 0; /* send 400 on a empty namespace attribute */
! 2074:
! 2075: /* start response */
! 2076:
! 2077: if (SQLITE_OK != sqlite3_exec(p->conf.sql, "BEGIN TRANSACTION", NULL, NULL, &err)) {
! 2078: log_error_write(srv, __FILE__, __LINE__, "ss", "can't open transaction:", err);
! 2079: sqlite3_free(err);
! 2080:
! 2081: goto propmatch_cleanup;
! 2082: }
! 2083:
! 2084: /* a UPDATE request, we know 'set' and 'remove' */
! 2085: for (cmd = rootnode->children; cmd; cmd = cmd->next) {
! 2086: xmlNode *props;
! 2087: /* either set or remove */
! 2088:
! 2089: if ((0 == xmlStrcmp(cmd->name, BAD_CAST "set")) ||
! 2090: (0 == xmlStrcmp(cmd->name, BAD_CAST "remove"))) {
! 2091:
! 2092: sqlite3_stmt *stmt;
! 2093:
! 2094: stmt = (0 == xmlStrcmp(cmd->name, BAD_CAST "remove")) ?
! 2095: p->conf.stmt_delete_prop : p->conf.stmt_update_prop;
! 2096:
! 2097: for (props = cmd->children; props; props = props->next) {
! 2098: if (0 == xmlStrcmp(props->name, BAD_CAST "prop")) {
! 2099: xmlNode *prop;
! 2100: int r;
! 2101:
! 2102: prop = props->children;
! 2103:
! 2104: if (prop->ns &&
! 2105: (0 == xmlStrcmp(prop->ns->href, BAD_CAST "")) &&
! 2106: (0 != xmlStrcmp(prop->ns->prefix, BAD_CAST ""))) {
! 2107: log_error_write(srv, __FILE__, __LINE__, "ss",
! 2108: "no name space for:",
! 2109: prop->name);
! 2110:
! 2111: empty_ns = 1;
! 2112: break;
! 2113: }
! 2114:
! 2115: sqlite3_reset(stmt);
! 2116:
! 2117: /* bind the values to the insert */
! 2118:
! 2119: sqlite3_bind_text(stmt, 1,
! 2120: con->uri.path->ptr,
! 2121: con->uri.path->used - 1,
! 2122: SQLITE_TRANSIENT);
! 2123: sqlite3_bind_text(stmt, 2,
! 2124: (char *)prop->name,
! 2125: strlen((char *)prop->name),
! 2126: SQLITE_TRANSIENT);
! 2127: if (prop->ns) {
! 2128: sqlite3_bind_text(stmt, 3,
! 2129: (char *)prop->ns->href,
! 2130: strlen((char *)prop->ns->href),
! 2131: SQLITE_TRANSIENT);
! 2132: } else {
! 2133: sqlite3_bind_text(stmt, 3,
! 2134: "",
! 2135: 0,
! 2136: SQLITE_TRANSIENT);
! 2137: }
! 2138: if (stmt == p->conf.stmt_update_prop) {
! 2139: sqlite3_bind_text(stmt, 4,
! 2140: (char *)xmlNodeGetContent(prop),
! 2141: strlen((char *)xmlNodeGetContent(prop)),
! 2142: SQLITE_TRANSIENT);
! 2143: }
! 2144:
! 2145: if (SQLITE_DONE != (r = sqlite3_step(stmt))) {
! 2146: log_error_write(srv, __FILE__, __LINE__, "ss",
! 2147: "sql-set failed:", sqlite3_errmsg(p->conf.sql));
! 2148: }
! 2149: }
! 2150: }
! 2151: if (empty_ns) break;
! 2152: }
! 2153: }
! 2154:
! 2155: if (empty_ns) {
! 2156: if (SQLITE_OK != sqlite3_exec(p->conf.sql, "ROLLBACK", NULL, NULL, &err)) {
! 2157: log_error_write(srv, __FILE__, __LINE__, "ss", "can't rollback transaction:", err);
! 2158: sqlite3_free(err);
! 2159:
! 2160: goto propmatch_cleanup;
! 2161: }
! 2162:
! 2163: con->http_status = 400;
! 2164: } else {
! 2165: if (SQLITE_OK != sqlite3_exec(p->conf.sql, "COMMIT", NULL, NULL, &err)) {
! 2166: log_error_write(srv, __FILE__, __LINE__, "ss", "can't commit transaction:", err);
! 2167: sqlite3_free(err);
! 2168:
! 2169: goto propmatch_cleanup;
! 2170: }
! 2171: con->http_status = 200;
! 2172: }
! 2173: con->file_finished = 1;
! 2174:
! 2175: return HANDLER_FINISHED;
! 2176: }
! 2177:
! 2178: propmatch_cleanup:
! 2179:
! 2180: xmlFreeDoc(xml);
! 2181: } else {
! 2182: con->http_status = 400;
! 2183: return HANDLER_FINISHED;
! 2184: }
! 2185: }
! 2186: #endif
! 2187: con->http_status = 501;
! 2188: return HANDLER_FINISHED;
! 2189: case HTTP_METHOD_LOCK:
! 2190: /**
! 2191: * a mac wants to write
! 2192: *
! 2193: * LOCK /dav/expire.txt HTTP/1.1\r\n
! 2194: * User-Agent: WebDAVFS/1.3 (01308000) Darwin/8.1.0 (Power Macintosh)\r\n
! 2195: * Accept: * / *\r\n
! 2196: * Depth: 0\r\n
! 2197: * Timeout: Second-600\r\n
! 2198: * Content-Type: text/xml; charset=\"utf-8\"\r\n
! 2199: * Content-Length: 229\r\n
! 2200: * Connection: keep-alive\r\n
! 2201: * Host: 192.168.178.23:1025\r\n
! 2202: * \r\n
! 2203: * <?xml version=\"1.0\" encoding=\"utf-8\"?>\n
! 2204: * <D:lockinfo xmlns:D=\"DAV:\">\n
! 2205: * <D:lockscope><D:exclusive/></D:lockscope>\n
! 2206: * <D:locktype><D:write/></D:locktype>\n
! 2207: * <D:owner>\n
! 2208: * <D:href>http://www.apple.com/webdav_fs/</D:href>\n
! 2209: * </D:owner>\n
! 2210: * </D:lockinfo>\n
! 2211: */
! 2212:
! 2213: if (depth != 0 && depth != -1) {
! 2214: con->http_status = 400;
! 2215:
! 2216: return HANDLER_FINISHED;
! 2217: }
! 2218:
! 2219: #ifdef USE_LOCKS
! 2220: if (con->request.content_length) {
! 2221: xmlDocPtr xml;
! 2222: buffer *hdr_if = NULL;
! 2223:
! 2224: if (NULL != (ds = (data_string *)array_get_element(con->request.headers, "If"))) {
! 2225: hdr_if = ds->value;
! 2226: }
! 2227:
! 2228: /* we don't support Depth: Infinity on locks */
! 2229: if (hdr_if == NULL && depth == -1) {
! 2230: con->http_status = 409; /* Conflict */
! 2231:
! 2232: return HANDLER_FINISHED;
! 2233: }
! 2234:
! 2235: if (1 == webdav_parse_chunkqueue(srv, con, p, con->request_content_queue, &xml)) {
! 2236: xmlNode *rootnode = xmlDocGetRootElement(xml);
! 2237:
! 2238: assert(rootnode);
! 2239:
! 2240: if (0 == xmlStrcmp(rootnode->name, BAD_CAST "lockinfo")) {
! 2241: xmlNode *lockinfo;
! 2242: const xmlChar *lockscope = NULL, *locktype = NULL; /* TODO: compiler says unused: *owner = NULL; */
! 2243:
! 2244: for (lockinfo = rootnode->children; lockinfo; lockinfo = lockinfo->next) {
! 2245: if (0 == xmlStrcmp(lockinfo->name, BAD_CAST "lockscope")) {
! 2246: xmlNode *value;
! 2247: for (value = lockinfo->children; value; value = value->next) {
! 2248: if ((0 == xmlStrcmp(value->name, BAD_CAST "exclusive")) ||
! 2249: (0 == xmlStrcmp(value->name, BAD_CAST "shared"))) {
! 2250: lockscope = value->name;
! 2251: } else {
! 2252: con->http_status = 400;
! 2253:
! 2254: xmlFreeDoc(xml);
! 2255: return HANDLER_FINISHED;
! 2256: }
! 2257: }
! 2258: } else if (0 == xmlStrcmp(lockinfo->name, BAD_CAST "locktype")) {
! 2259: xmlNode *value;
! 2260: for (value = lockinfo->children; value; value = value->next) {
! 2261: if ((0 == xmlStrcmp(value->name, BAD_CAST "write"))) {
! 2262: locktype = value->name;
! 2263: } else {
! 2264: con->http_status = 400;
! 2265:
! 2266: xmlFreeDoc(xml);
! 2267: return HANDLER_FINISHED;
! 2268: }
! 2269: }
! 2270:
! 2271: } else if (0 == xmlStrcmp(lockinfo->name, BAD_CAST "owner")) {
! 2272: }
! 2273: }
! 2274:
! 2275: if (lockscope && locktype) {
! 2276: sqlite3_stmt *stmt = p->conf.stmt_read_lock_by_uri;
! 2277:
! 2278: /* is this resourse already locked ? */
! 2279:
! 2280: /* SELECT locktoken, resource, lockscope, locktype, owner, depth, timeout
! 2281: * FROM locks
! 2282: * WHERE resource = ? */
! 2283:
! 2284: if (stmt) {
! 2285:
! 2286: sqlite3_reset(stmt);
! 2287:
! 2288: sqlite3_bind_text(stmt, 1,
! 2289: p->uri.path->ptr,
! 2290: p->uri.path->used - 1,
! 2291: SQLITE_TRANSIENT);
! 2292:
! 2293: /* it is the PK */
! 2294: while (SQLITE_ROW == sqlite3_step(stmt)) {
! 2295: /* we found a lock
! 2296: * 1. is it compatible ?
! 2297: * 2. is it ours */
! 2298: char *sql_lockscope = (char *)sqlite3_column_text(stmt, 2);
! 2299:
! 2300: if (strcmp(sql_lockscope, "exclusive")) {
! 2301: con->http_status = 423;
! 2302: } else if (0 == xmlStrcmp(lockscope, BAD_CAST "exclusive")) {
! 2303: /* resourse is locked with a shared lock
! 2304: * client wants exclusive */
! 2305: con->http_status = 423;
! 2306: }
! 2307: }
! 2308: if (con->http_status == 423) {
! 2309: xmlFreeDoc(xml);
! 2310: return HANDLER_FINISHED;
! 2311: }
! 2312: }
! 2313:
! 2314: stmt = p->conf.stmt_create_lock;
! 2315: if (stmt) {
! 2316: /* create a lock-token */
! 2317: uuid_t id;
! 2318: char uuid[37] /* 36 + \0 */;
! 2319:
! 2320: uuid_generate(id);
! 2321: uuid_unparse(id, uuid);
! 2322:
! 2323: buffer_copy_string_len(p->tmp_buf, CONST_STR_LEN("opaquelocktoken:"));
! 2324: buffer_append_string(p->tmp_buf, uuid);
! 2325:
! 2326: /* "CREATE TABLE locks ("
! 2327: * " locktoken TEXT NOT NULL,"
! 2328: * " resource TEXT NOT NULL,"
! 2329: * " lockscope TEXT NOT NULL,"
! 2330: * " locktype TEXT NOT NULL,"
! 2331: * " owner TEXT NOT NULL,"
! 2332: * " depth INT NOT NULL,"
! 2333: */
! 2334:
! 2335: sqlite3_reset(stmt);
! 2336:
! 2337: sqlite3_bind_text(stmt, 1,
! 2338: CONST_BUF_LEN(p->tmp_buf),
! 2339: SQLITE_TRANSIENT);
! 2340:
! 2341: sqlite3_bind_text(stmt, 2,
! 2342: CONST_BUF_LEN(con->uri.path),
! 2343: SQLITE_TRANSIENT);
! 2344:
! 2345: sqlite3_bind_text(stmt, 3,
! 2346: (const char *)lockscope,
! 2347: xmlStrlen(lockscope),
! 2348: SQLITE_TRANSIENT);
! 2349:
! 2350: sqlite3_bind_text(stmt, 4,
! 2351: (const char *)locktype,
! 2352: xmlStrlen(locktype),
! 2353: SQLITE_TRANSIENT);
! 2354:
! 2355: /* owner */
! 2356: sqlite3_bind_text(stmt, 5,
! 2357: "",
! 2358: 0,
! 2359: SQLITE_TRANSIENT);
! 2360:
! 2361: /* depth */
! 2362: sqlite3_bind_int(stmt, 6,
! 2363: depth);
! 2364:
! 2365:
! 2366: if (SQLITE_DONE != sqlite3_step(stmt)) {
! 2367: log_error_write(srv, __FILE__, __LINE__, "ss",
! 2368: "create lock:", sqlite3_errmsg(p->conf.sql));
! 2369: }
! 2370:
! 2371: /* looks like we survived */
! 2372: webdav_lockdiscovery(srv, con, p->tmp_buf, (const char *)lockscope, (const char *)locktype, depth);
! 2373:
! 2374: con->http_status = 201;
! 2375: con->file_finished = 1;
! 2376: }
! 2377: }
! 2378: }
! 2379:
! 2380: xmlFreeDoc(xml);
! 2381: return HANDLER_FINISHED;
! 2382: } else {
! 2383: con->http_status = 400;
! 2384: return HANDLER_FINISHED;
! 2385: }
! 2386: } else {
! 2387:
! 2388: if (NULL != (ds = (data_string *)array_get_element(con->request.headers, "If"))) {
! 2389: buffer *locktoken = ds->value;
! 2390: sqlite3_stmt *stmt = p->conf.stmt_refresh_lock;
! 2391:
! 2392: /* remove the < > around the token */
! 2393: if (locktoken->used < 6) {
! 2394: con->http_status = 400;
! 2395:
! 2396: return HANDLER_FINISHED;
! 2397: }
! 2398:
! 2399: buffer_copy_string_len(p->tmp_buf, locktoken->ptr + 2, locktoken->used - 5);
! 2400:
! 2401: sqlite3_reset(stmt);
! 2402:
! 2403: sqlite3_bind_text(stmt, 1,
! 2404: CONST_BUF_LEN(p->tmp_buf),
! 2405: SQLITE_TRANSIENT);
! 2406:
! 2407: if (SQLITE_DONE != sqlite3_step(stmt)) {
! 2408: log_error_write(srv, __FILE__, __LINE__, "ss",
! 2409: "refresh lock:", sqlite3_errmsg(p->conf.sql));
! 2410: }
! 2411:
! 2412: webdav_lockdiscovery(srv, con, p->tmp_buf, "exclusive", "write", 0);
! 2413:
! 2414: con->http_status = 200;
! 2415: con->file_finished = 1;
! 2416: return HANDLER_FINISHED;
! 2417: } else {
! 2418: /* we need a lock-token to refresh */
! 2419: con->http_status = 400;
! 2420:
! 2421: return HANDLER_FINISHED;
! 2422: }
! 2423: }
! 2424: break;
! 2425: #else
! 2426: con->http_status = 501;
! 2427: return HANDLER_FINISHED;
! 2428: #endif
! 2429: case HTTP_METHOD_UNLOCK:
! 2430: #ifdef USE_LOCKS
! 2431: if (NULL != (ds = (data_string *)array_get_element(con->request.headers, "Lock-Token"))) {
! 2432: buffer *locktoken = ds->value;
! 2433: sqlite3_stmt *stmt = p->conf.stmt_remove_lock;
! 2434:
! 2435: /* remove the < > around the token */
! 2436: if (locktoken->used < 4) {
! 2437: con->http_status = 400;
! 2438:
! 2439: return HANDLER_FINISHED;
! 2440: }
! 2441:
! 2442: /**
! 2443: * FIXME:
! 2444: *
! 2445: * if the resourse is locked:
! 2446: * - by us: unlock
! 2447: * - by someone else: 401
! 2448: * if the resource is not locked:
! 2449: * - 412
! 2450: * */
! 2451:
! 2452: buffer_copy_string_len(p->tmp_buf, locktoken->ptr + 1, locktoken->used - 3);
! 2453:
! 2454: sqlite3_reset(stmt);
! 2455:
! 2456: sqlite3_bind_text(stmt, 1,
! 2457: CONST_BUF_LEN(p->tmp_buf),
! 2458: SQLITE_TRANSIENT);
! 2459:
! 2460: sqlite3_bind_text(stmt, 2,
! 2461: CONST_BUF_LEN(con->uri.path),
! 2462: SQLITE_TRANSIENT);
! 2463:
! 2464: if (SQLITE_DONE != sqlite3_step(stmt)) {
! 2465: log_error_write(srv, __FILE__, __LINE__, "ss",
! 2466: "remove lock:", sqlite3_errmsg(p->conf.sql));
! 2467: }
! 2468:
! 2469: if (0 == sqlite3_changes(p->conf.sql)) {
! 2470: con->http_status = 401;
! 2471: } else {
! 2472: con->http_status = 204;
! 2473: }
! 2474: return HANDLER_FINISHED;
! 2475: } else {
! 2476: /* we need a lock-token to unlock */
! 2477: con->http_status = 400;
! 2478:
! 2479: return HANDLER_FINISHED;
! 2480: }
! 2481: break;
! 2482: #else
! 2483: con->http_status = 501;
! 2484: return HANDLER_FINISHED;
! 2485: #endif
! 2486: default:
! 2487: break;
! 2488: }
! 2489:
! 2490: /* not found */
! 2491: return HANDLER_GO_ON;
! 2492: }
! 2493:
! 2494:
! 2495: /* this function is called at dlopen() time and inits the callbacks */
! 2496:
! 2497: int mod_webdav_plugin_init(plugin *p);
! 2498: int mod_webdav_plugin_init(plugin *p) {
! 2499: p->version = LIGHTTPD_VERSION_ID;
! 2500: p->name = buffer_init_string("webdav");
! 2501:
! 2502: p->init = mod_webdav_init;
! 2503: p->handle_uri_clean = mod_webdav_uri_handler;
! 2504: p->handle_physical = mod_webdav_subrequest_handler;
! 2505: p->set_defaults = mod_webdav_set_defaults;
! 2506: p->cleanup = mod_webdav_free;
! 2507:
! 2508: p->data = NULL;
! 2509:
! 2510: return 0;
! 2511: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mod_webdav.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / lighttpd / src