Apache2
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
mod_dav.h
Go to the documentation of this file.
1 /* Licensed to the Apache Software Foundation (ASF) under one or more
2  * contributor license agreements. See the NOTICE file distributed with
3  * this work for additional information regarding copyright ownership.
4  * The ASF licenses this file to You under the Apache License, Version 2.0
5  * (the "License"); you may not use this file except in compliance with
6  * the License. You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
26 #ifndef _MOD_DAV_H_
27 #define _MOD_DAV_H_
28 
29 #include "apr_hooks.h"
30 #include "apr_hash.h"
31 #include "apr_dbm.h"
32 #include "apr_tables.h"
33 
34 #include "httpd.h"
35 #include "util_filter.h"
36 #include "util_xml.h"
37 
38 #include <limits.h> /* for INT_MAX */
39 #include <time.h> /* for time_t */
40 
41 #ifdef __cplusplus
42 extern "C" {
43 #endif
44 
45 
46 #define DAV_VERSION AP_SERVER_BASEREVISION
47 
48 #define DAV_XML_HEADER "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
49 #define DAV_XML_CONTENT_TYPE "text/xml; charset=\"utf-8\""
50 
51 #define DAV_READ_BLOCKSIZE 2048 /* used for reading input blocks */
52 
53 #define DAV_RESPONSE_BODY_1 "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" \"http://www.w3.org/TR/html4/strict.dtd\">\n<html>\n<head>\n<title>"
54 #define DAV_RESPONSE_BODY_2 "</title>\n</head><body>\n<h1>"
55 #define DAV_RESPONSE_BODY_3 "</h1>\n<p>"
56 #define DAV_RESPONSE_BODY_4 "</p>\n"
57 #define DAV_RESPONSE_BODY_5 "</body></html>\n"
58 
59 #define DAV_DO_COPY 0
60 #define DAV_DO_MOVE 1
61 
62 
63 #if 1
64 #define DAV_DEBUG 1
65 #define DEBUG_CR "\n"
66 #define DBG0(f) ap_log_error(APLOG_MARK, \
67  APLOG_ERR, 0, NULL, (f))
68 #define DBG1(f,a1) ap_log_error(APLOG_MARK, \
69  APLOG_ERR, 0, NULL, f, a1)
70 #define DBG2(f,a1,a2) ap_log_error(APLOG_MARK, \
71  APLOG_ERR, 0, NULL, f, a1, a2)
72 #define DBG3(f,a1,a2,a3) ap_log_error(APLOG_MARK, \
73  APLOG_ERR, 0, NULL, f, a1, a2, a3)
74 #else
75 #undef DAV_DEBUG
76 #define DEBUG_CR ""
77 #endif
78 
79 #define DAV_INFINITY INT_MAX /* for the Depth: header */
80 
81 /* Create a set of DAV_DECLARE(type), DAV_DECLARE_NONSTD(type) and
82  * DAV_DECLARE_DATA with appropriate export and import tags for the platform
83  */
84 #if !defined(WIN32)
85 #define DAV_DECLARE(type) type
86 #define DAV_DECLARE_NONSTD(type) type
87 #define DAV_DECLARE_DATA
88 #elif defined(DAV_DECLARE_STATIC)
89 #define DAV_DECLARE(type) type __stdcall
90 #define DAV_DECLARE_NONSTD(type) type
91 #define DAV_DECLARE_DATA
92 #elif defined(DAV_DECLARE_EXPORT)
93 #define DAV_DECLARE(type) __declspec(dllexport) type __stdcall
94 #define DAV_DECLARE_NONSTD(type) __declspec(dllexport) type
95 #define DAV_DECLARE_DATA __declspec(dllexport)
96 #else
97 #define DAV_DECLARE(type) __declspec(dllimport) type __stdcall
98 #define DAV_DECLARE_NONSTD(type) __declspec(dllimport) type
99 #define DAV_DECLARE_DATA __declspec(dllimport)
100 #endif
101 
102 /* --------------------------------------------------------------------
103 **
104 ** ERROR MANAGEMENT
105 */
106 
107 /*
108 ** dav_error structure.
109 **
110 ** In most cases, mod_dav uses a pointer to a dav_error structure. If the
111 ** pointer is NULL, then no error has occurred.
112 **
113 ** In certain cases, a dav_error structure is directly used. In these cases,
114 ** a status value of 0 means that an error has not occurred.
115 **
116 ** Note: this implies that status != 0 whenever an error occurs.
117 **
118 ** The desc field is optional (it may be NULL). When NULL, it typically
119 ** implies that Apache has a proper description for the specified status.
120 */
121 typedef struct dav_error {
122  int status; /* suggested HTTP status (0 for no error) */
123  int error_id; /* DAV-specific error ID */
124  const char *desc; /* DAV:responsedescription and error log */
125 
126  apr_status_t aprerr; /* APR error if any, or 0/APR_SUCCESS */
127 
128  const char *namespace; /* [optional] namespace of error */
129  const char *tagname; /* name of error-tag */
130 
131  struct dav_error *prev; /* previous error (in stack) */
132 
133  const char *childtags; /* error-tag may have children */
134 
135 } dav_error;
136 
137 /*
138 ** Create a new error structure. save_errno will be filled with the current
139 ** errno value.
140 */
141 DAV_DECLARE(dav_error*) dav_new_error(apr_pool_t *p, int status,
143  const char *desc);
144 
145 
146 /*
147 ** Create a new error structure with tagname and (optional) namespace;
148 ** namespace may be NULL, which means "DAV:".
149 */
150 DAV_DECLARE(dav_error*) dav_new_error_tag(apr_pool_t *p, int status,
151  int error_id, apr_status_t aprerr,
152  const char *desc,
153  const char *namespace,
154  const char *tagname);
155 
156 
157 /*
158 ** Push a new error description onto the stack of errors.
159 **
160 ** This function is used to provide an additional description to an existing
161 ** error.
162 **
163 ** <status> should contain the caller's view of what the current status is,
164 ** given the underlying error. If it doesn't have a better idea, then the
165 ** caller should pass prev->status.
166 **
167 ** <error_id> can specify a new error_id since the topmost description has
168 ** changed.
169 */
170 DAV_DECLARE(dav_error*) dav_push_error(apr_pool_t *p, int status, int error_id,
171  const char *desc, dav_error *prev);
172 
173 
174 /*
175 ** Join two errors together.
176 **
177 ** This function is used to add a new error stack onto an existing error so
178 ** that subsequent errors can be reported after the first error. It returns
179 ** the correct error stack to use so that the caller can blindly call it
180 ** without checking that both dest and src are not NULL.
181 **
182 ** <dest> is the error stack that the error will be added to.
183 **
184 ** <src> is the error stack that will be appended.
185 */
186 DAV_DECLARE(dav_error*) dav_join_error(dav_error* dest, dav_error* src);
187 
188 typedef struct dav_response dav_response;
189 
190 /*
191 ** dav_handle_err()
192 **
193 ** Handle the standard error processing. <err> must be non-NULL.
194 **
195 ** <response> is set by the following:
196 ** - dav_validate_request()
197 ** - dav_add_lock()
198 ** - repos_hooks->remove_resource
199 ** - repos_hooks->move_resource
200 ** - repos_hooks->copy_resource
201 ** - vsn_hooks->update
202 */
203 DAV_DECLARE(int) dav_handle_err(request_rec *r, dav_error *err,
204  dav_response *response);
205 
206 /* error ID values... */
207 
208 /* IF: header errors */
209 #define DAV_ERR_IF_PARSE 100 /* general parsing error */
210 #define DAV_ERR_IF_MULTIPLE_NOT 101 /* multiple "Not" found */
211 #define DAV_ERR_IF_UNK_CHAR 102 /* unknown char in header */
212 #define DAV_ERR_IF_ABSENT 103 /* no locktokens given */
213 #define DAV_ERR_IF_TAGGED 104 /* in parsing tagged-list */
214 #define DAV_ERR_IF_UNCLOSED_PAREN 105 /* in no-tagged-list */
215 
216 /* Prop DB errors */
217 #define DAV_ERR_PROP_BAD_MAJOR 200 /* major version was wrong */
218 #define DAV_ERR_PROP_READONLY 201 /* prop is read-only */
219 #define DAV_ERR_PROP_NO_DATABASE 202 /* writable db not avail */
220 #define DAV_ERR_PROP_NOT_FOUND 203 /* prop not found */
221 #define DAV_ERR_PROP_BAD_LOCKDB 204 /* could not open lockdb */
222 #define DAV_ERR_PROP_OPENING 205 /* problem opening propdb */
223 #define DAV_ERR_PROP_EXEC 206 /* problem exec'ing patch */
224 
225 /* Predefined DB errors */
226 /* ### any to define?? */
227 
228 /* Predefined locking system errors */
229 #define DAV_ERR_LOCK_OPENDB 400 /* could not open lockdb */
230 #define DAV_ERR_LOCK_NO_DB 401 /* no database defined */
231 #define DAV_ERR_LOCK_CORRUPT_DB 402 /* DB is corrupt */
232 #define DAV_ERR_LOCK_UNK_STATE_TOKEN 403 /* unknown State-token */
233 #define DAV_ERR_LOCK_PARSE_TOKEN 404 /* bad opaquelocktoken */
234 #define DAV_ERR_LOCK_SAVE_LOCK 405 /* err saving locks */
235 
236 /*
237 ** Some comments on Error ID values:
238 **
239 ** The numbers do not necessarily need to be unique. Uniqueness simply means
240 ** that two errors that have not been predefined above can be distinguished
241 ** from each other. At the moment, mod_dav does not use this distinguishing
242 ** feature, but it could be used in the future to collapse <response> elements
243 ** into groups based on the error ID (and associated responsedescription).
244 **
245 ** If a compute_desc is provided, then the error ID should be unique within
246 ** the context of the compute_desc function (so the function can figure out
247 ** what to filled into the desc).
248 **
249 ** Basically, subsystems can ignore defining new error ID values if they want
250 ** to. The subsystems *do* need to return the predefined errors when
251 ** appropriate, so that mod_dav can figure out what to do. Subsystems can
252 ** simply leave the error ID field unfilled (zero) if there isn't an error
253 ** that must be placed there.
254 */
255 
256 
257 /* --------------------------------------------------------------------
258 **
259 ** HOOK STRUCTURES
260 **
261 ** These are here for forward-declaration purposes. For more info, see
262 ** the section title "HOOK HANDLING" for more information, plus each
263 ** structure definition.
264 */
265 
266 /* forward-declare this structure */
274 
275 /* ### deprecated name */
277 
278 
279 /* --------------------------------------------------------------------
280 **
281 ** RESOURCE HANDLING
282 */
283 
284 /*
285 ** Resource Types:
286 ** The base protocol defines only file and collection resources.
287 ** The versioning protocol defines several additional resource types
288 ** to represent artifacts of a version control system.
289 **
290 ** This enumeration identifies the type of URL used to identify the
291 ** resource. Since the same resource may have more than one type of
292 ** URL which can identify it, dav_resource_type cannot be used
293 ** alone to determine the type of the resource; attributes of the
294 ** dav_resource object must also be consulted.
295 */
296 typedef enum {
298 
299  DAV_RESOURCE_TYPE_REGULAR, /* file or collection; could be
300  * unversioned, or version selector,
301  * or baseline selector */
302 
303  DAV_RESOURCE_TYPE_VERSION, /* version or baseline URL */
304 
305  DAV_RESOURCE_TYPE_HISTORY, /* version or baseline history URL */
306 
307  DAV_RESOURCE_TYPE_WORKING, /* working resource URL */
308 
309  DAV_RESOURCE_TYPE_WORKSPACE, /* workspace URL */
310 
311  DAV_RESOURCE_TYPE_ACTIVITY, /* activity URL */
312 
313  DAV_RESOURCE_TYPE_PRIVATE /* repository-private type */
314 
316 
317 /*
318 ** Opaque, repository-specific information for a resource.
319 */
321 
323 
324 /*
325 ** Resource descriptor, generated by a repository provider.
326 **
327 ** Note: the lock-null state is not explicitly represented here,
328 ** since it may be expensive to compute. Use dav_get_resource_state()
329 ** to determine whether a non-existent resource is a lock-null resource.
330 **
331 ** A quick explanation of how the flags can apply to different resources:
332 **
333 ** unversioned file or collection:
334 ** type = DAV_RESOURCE_TYPE_REGULAR
335 ** exists = ? (1 if exists)
336 ** collection = ? (1 if collection)
337 ** versioned = 0
338 ** baselined = 0
339 ** working = 0
340 **
341 ** version-controlled resource or configuration:
342 ** type = DAV_RESOURCE_TYPE_REGULAR
343 ** exists = 1
344 ** collection = ? (1 if collection)
345 ** versioned = 1
346 ** baselined = ? (1 if configuration)
347 ** working = ? (1 if checked out)
348 **
349 ** version/baseline history:
350 ** type = DAV_RESOURCE_TYPE_HISTORY
351 ** exists = 1
352 ** collection = 0
353 ** versioned = 0
354 ** baselined = 0
355 ** working = 0
356 **
357 ** version/baseline:
358 ** type = DAV_RESOURCE_TYPE_VERSION
359 ** exists = 1
360 ** collection = ? (1 if collection)
361 ** versioned = 1
362 ** baselined = ? (1 if baseline)
363 ** working = 0
364 **
365 ** working resource:
366 ** type = DAV_RESOURCE_TYPE_WORKING
367 ** exists = 1
368 ** collection = ? (1 if collection)
369 ** versioned = 1
370 ** baselined = 0
371 ** working = 1
372 **
373 ** workspace:
374 ** type = DAV_RESOURCE_TYPE_WORKSPACE
375 ** exists = ? (1 if exists)
376 ** collection = 1
377 ** versioned = ? (1 if version-controlled)
378 ** baselined = ? (1 if baseline-controlled)
379 ** working = ? (1 if checked out)
380 **
381 ** activity:
382 ** type = DAV_RESOURCE_TYPE_ACTIVITY
383 ** exists = ? (1 if exists)
384 ** collection = 0
385 ** versioned = 0
386 ** baselined = 0
387 ** working = 0
388 */
389 typedef struct dav_resource {
391 
392  int exists; /* 0 => null resource */
393 
394  int collection; /* 0 => file; can be 1 for
395  * REGULAR, VERSION, and WORKING resources,
396  * and is always 1 for WORKSPACE */
397 
398  int versioned; /* 0 => unversioned; can be 1 for
399  * REGULAR and WORKSPACE resources,
400  * and is always 1 for VERSION and WORKING */
401 
402  int baselined; /* 0 => not baselined; can be 1 for
403  * REGULAR, VERSION, and WORKSPACE resources;
404  * versioned == 1 when baselined == 1 */
405 
406  int working; /* 0 => not checked out; can be 1 for
407  * REGULAR and WORKSPACE resources,
408  * and is always 1 for WORKING */
409 
410  const char *uri; /* the URI for this resource;
411  * currently has an ABI flaw where sometimes it is
412  * assumed to be encoded and sometimes not */
413 
414  dav_resource_private *info; /* the provider's private info */
415 
416  const dav_hooks_repository *hooks; /* hooks used for this resource */
417 
418  /* When allocating items related specifically to this resource, the
419  following pool should be used. Its lifetime will be at least as
420  long as the dav_resource structure. */
422 
423  const dav_acl_provider *acls; /* acls used for this resource */
424 
425  void *ctx; /* additional parameter */
426 
427 } dav_resource;
428 
429 /*
430 ** Lock token type. Lock providers define the details of a lock token.
431 ** However, all providers are expected to at least be able to parse
432 ** the "opaquelocktoken" scheme, which is represented by a uuid_t.
433 */
435 
436 
437 /* --------------------------------------------------------------------
438 **
439 ** BUFFER HANDLING
440 **
441 ** These buffers are used as a lightweight buffer reuse mechanism. Apache
442 ** provides sub-pool creation and destruction to much the same effect, but
443 ** the sub-pools are a bit more general and heavyweight than these buffers.
444 */
445 
446 /* buffer for reuse; can grow to accommodate needed size */
447 typedef struct
448 {
449  apr_size_t alloc_len; /* how much has been allocated */
450  apr_size_t cur_len; /* how much is currently being used */
451  char *buf; /* buffer contents */
452 } dav_buffer;
453 #define DAV_BUFFER_MINSIZE 256 /* minimum size for buffer */
454 #define DAV_BUFFER_PAD 64 /* amount of pad when growing */
455 
456 /* set the cur_len to the given size and ensure space is available */
457 DAV_DECLARE(void) dav_set_bufsize(apr_pool_t *p, dav_buffer *pbuf,
458  apr_size_t size);
459 
460 /* initialize a buffer and copy the specified (null-term'd) string into it */
461 DAV_DECLARE(void) dav_buffer_init(apr_pool_t *p, dav_buffer *pbuf,
462  const char *str);
463 
464 /* check that the buffer can accommodate <extra_needed> more bytes */
465 DAV_DECLARE(void) dav_check_bufsize(apr_pool_t *p, dav_buffer *pbuf,
467 
468 /* append a string to the end of the buffer, adjust length */
469 DAV_DECLARE(void) dav_buffer_append(apr_pool_t *p, dav_buffer *pbuf,
470  const char *str);
471 
472 /* place a string on the end of the buffer, do NOT adjust length */
473 DAV_DECLARE(void) dav_buffer_place(apr_pool_t *p, dav_buffer *pbuf,
474  const char *str);
475 
476 /* place some memory on the end of a buffer; do NOT adjust length */
477 DAV_DECLARE(void) dav_buffer_place_mem(apr_pool_t *p, dav_buffer *pbuf,
478  const void *mem, apr_size_t amt,
479  apr_size_t pad);
480 
481 
482 /* --------------------------------------------------------------------
483 **
484 ** HANDY UTILITIES
485 */
486 
487 /* contains results from one of the getprop functions */
488 typedef struct
489 {
490  apr_text * propstats; /* <propstat> element text */
491  apr_text * xmlns; /* namespace decls for <response> elem */
493 
494 /* holds the contents of a <response> element */
495 struct dav_response
496 {
497  const char *href; /* always */
498  const char *desc; /* optional description at <response> level */
499 
500  /* use status if propresult.propstats is NULL. */
502 
503  int status;
504 
505  struct dav_response *next;
506 };
507 
508 typedef struct
509 {
510  request_rec *rnew; /* new subrequest */
511  dav_error err; /* potential error response */
513 
514 
515 DAV_DECLARE(dav_lookup_result) dav_lookup_uri(const char *uri, request_rec *r,
516  int must_be_absolute);
517 
518 /* defines type of property info a provider is to return */
519 typedef enum {
520  DAV_PROP_INSERT_NOTDEF, /* property is defined by this provider,
521  but nothing was inserted because the
522  (live) property is not defined for this
523  resource (it may be present as a dead
524  property). */
525  DAV_PROP_INSERT_NOTSUPP, /* property is recognized by this provider,
526  but it is not supported, and cannot be
527  treated as a dead property */
528  DAV_PROP_INSERT_NAME, /* a property name (empty elem) was
529  inserted into the text block */
530  DAV_PROP_INSERT_VALUE, /* a property name/value pair was inserted
531  into the text block */
532  DAV_PROP_INSERT_SUPPORTED /* a supported live property was added to
533  the text block as a
534  <DAV:supported-live-property> element */
536 
537 /* ### this stuff is private to dav/fs/repos.c; move it... */
538 /* format a time string (buf must be at least DAV_TIMEBUF_SIZE chars) */
539 #define DAV_STYLE_ISO8601 1
540 #define DAV_STYLE_RFC822 2
541 #define DAV_TIMEBUF_SIZE 30
542 
543 /* Write a complete RESPONSE object out as a <DAV:response> xml
544  * element. Data is sent into brigade BB, which is auto-flushed into
545  * the output filter stack for request R. Use POOL for any temporary
546  * allocations.
547  *
548  * [Presumably the <multistatus> tag has already been written; this
549  * routine is shared by dav_send_multistatus and dav_stream_response.]
550  */
551 DAV_DECLARE(void) dav_send_one_response(dav_response *response,
553  request_rec *r,
554  apr_pool_t *pool);
555 
556 /* Factorized helper function: prep request_rec R for a multistatus
557  * response and write <multistatus> tag into BB, destined for
558  * R->output_filters. Use xml NAMESPACES in initial tag, if
559  * non-NULL.
560  */
561 DAV_DECLARE(void) dav_begin_multistatus(apr_bucket_brigade *bb,
562  request_rec *r, int status,
564 
565 /* Finish a multistatus response started by dav_begin_multistatus: */
566 DAV_DECLARE(apr_status_t) dav_finish_multistatus(request_rec *r,
567  apr_bucket_brigade *bb);
568 
569 /* Send a multistatus response */
570 DAV_DECLARE(void) dav_send_multistatus(request_rec *r, int status,
571  dav_response *first,
572  apr_array_header_t *namespaces);
573 
574 DAV_DECLARE(apr_text *) dav_failed_proppatch(apr_pool_t *p,
576 DAV_DECLARE(apr_text *) dav_success_proppatch(apr_pool_t *p,
577  apr_array_header_t *prop_ctx);
578 
579 DAV_DECLARE(int) dav_get_depth(request_rec *r, int def_depth);
580 
581 DAV_DECLARE(int) dav_validate_root(const apr_xml_doc *doc,
582  const char *tagname);
583 DAV_DECLARE(apr_xml_elem *) dav_find_child(const apr_xml_elem *elem,
584  const char *tagname);
585 
586 /* gather up all the CDATA into a single string */
587 DAV_DECLARE(const char *) dav_xml_get_cdata(const apr_xml_elem *elem, apr_pool_t *pool,
588  int strip_white);
589 
590 /*
591 ** XML namespace handling
592 **
593 ** This structure tracks namespace declarations (xmlns:prefix="URI").
594 ** It maintains a one-to-many relationship of URIs-to-prefixes. In other
595 ** words, one URI may be defined by many prefixes, but any specific
596 ** prefix will specify only one URI.
597 **
598 ** Prefixes using the "g###" pattern can be generated automatically if
599 ** the caller does not have specific prefix requirements.
600 */
601 typedef struct {
603  apr_hash_t *uri_prefix; /* map URIs to an available prefix */
604  apr_hash_t *prefix_uri; /* map all prefixes to their URIs */
605  int count; /* counter for "g###" prefixes */
607 
608 /* create an empty dav_xmlns_info structure */
609 DAV_DECLARE(dav_xmlns_info *) dav_xmlns_create(apr_pool_t *pool);
610 
611 /* add a specific prefix/URI pair. the prefix/uri should have a lifetime
612  at least that of xmlns->pool */
613 DAV_DECLARE(void) dav_xmlns_add(dav_xmlns_info *xi,
614  const char *prefix, const char *uri);
615 
616 /* add a URI (if not present); any prefix is acceptable and is returned.
617  the uri should have a lifetime at least that xmlns->pool */
618 DAV_DECLARE(const char *) dav_xmlns_add_uri(dav_xmlns_info *xi,
619  const char *uri);
620 
621 /* return the URI for a specified prefix (or NULL if the prefix is unknown) */
622 DAV_DECLARE(const char *) dav_xmlns_get_uri(dav_xmlns_info *xi,
623  const char *prefix);
624 
625 /* return an available prefix for a specified URI (or NULL if the URI
626  is unknown) */
627 DAV_DECLARE(const char *) dav_xmlns_get_prefix(dav_xmlns_info *xi,
628  const char *uri);
629 
630 /* generate xmlns declarations (appending into the given text) */
631 DAV_DECLARE(void) dav_xmlns_generate(dav_xmlns_info *xi,
633 
634 /* --------------------------------------------------------------------
635 **
636 ** DAV PLUGINS
637 */
638 
639 /* ### docco ... */
640 
641 /*
642 ** dav_provider
643 **
644 ** This structure wraps up all of the hooks that a mod_dav provider can
645 ** supply. The provider MUST supply <repos> and <propdb>. The rest are
646 ** optional and should contain NULL if that feature is not supplied.
647 **
648 ** Note that a provider cannot pick and choose portions from various
649 ** underlying implementations (which was theoretically possible in
650 ** mod_dav 1.0). There are too many dependencies between a dav_resource
651 ** (defined by <repos>) and the other functionality.
652 **
653 ** Live properties are not part of the dav_provider structure because they
654 ** are handled through the APR_HOOK interface (to allow for multiple liveprop
655 ** providers). The core always provides some properties, and then a given
656 ** provider will add more properties.
657 **
658 ** Some providers may need to associate a context with the dav_provider
659 ** structure -- the ctx field is available for storing this context. Just
660 ** leave it NULL if it isn't required.
661 */
662 typedef struct {
669 
670  void *ctx;
671 } dav_provider;
672 
673 /*
674 ** gather_propsets: gather all live property propset-URIs
675 **
676 ** The hook implementor should push one or more URIs into the specified
677 ** array. These URIs are returned in the DAV: header to let clients know
678 ** what sets of live properties are supported by the installation. mod_dav
679 ** will place open/close angle brackets around each value (much like
680 ** a Coded-URL); quotes and brackets should not be in the value.
681 **
682 ** Example: http://apache.org/dav/props/
683 **
684 ** (of course, use your own domain to ensure a unique value)
685 */
686 APR_DECLARE_EXTERNAL_HOOK(dav, DAV, void, gather_propsets,
687  (apr_array_header_t *uris))
688 
689 /*
690 ** find_liveprop: find a live property, returning a non-zero, unique,
691 ** opaque identifier.
692 **
693 ** If the hook implementor determines the specified URI/name refers to
694 ** one of its properties, then it should fill in HOOKS and return a
695 ** non-zero value. The returned value is the "property ID" and will
696 ** be passed to the various liveprop hook functions.
697 **
698 ** Return 0 if the property is not defined by the hook implementor.
699 */
700 APR_DECLARE_EXTERNAL_HOOK(dav, DAV, int, find_liveprop,
701  (const dav_resource *resource,
702  const char *ns_uri, const char *name,
703  const dav_hooks_liveprop **hooks))
704 
705 /*
706 ** insert_all_liveprops: insert all (known) live property names/values.
707 **
708 ** The hook implementor should append XML text to PHDR, containing liveprop
709 ** names. If INSVALUE is true, then the property values should also be
710 ** inserted into the output XML stream.
711 **
712 ** The liveprop provider should insert *all* known and *defined* live
713 ** properties on the specified resource. If a particular liveprop is
714 ** not defined for this resource, then it should not be inserted.
715 */
716 APR_DECLARE_EXTERNAL_HOOK(dav, DAV, void, insert_all_liveprops,
717  (request_rec *r, const dav_resource *resource,
719 
720 DAV_DECLARE(const dav_hooks_locks *) dav_get_lock_hooks(request_rec *r);
721 DAV_DECLARE(const dav_hooks_propdb *) dav_get_propdb_hooks(request_rec *r);
722 DAV_DECLARE(const dav_hooks_vsn *) dav_get_vsn_hooks(request_rec *r);
723 DAV_DECLARE(const dav_hooks_binding *) dav_get_binding_hooks(request_rec *r);
724 DAV_DECLARE(const dav_hooks_search *) dav_get_search_hooks(request_rec *r);
725 
726 DAV_DECLARE(void) dav_register_provider(apr_pool_t *p, const char *name,
727  const dav_provider *hooks);
728 DAV_DECLARE(const dav_provider *) dav_lookup_provider(const char *name);
729 DAV_DECLARE(const char *) dav_get_provider_name(request_rec *r);
730 
731 
732 /* ### deprecated */
733 #define DAV_GET_HOOKS_PROPDB(r) dav_get_propdb_hooks(r)
734 #define DAV_GET_HOOKS_LOCKS(r) dav_get_lock_hooks(r)
735 #define DAV_GET_HOOKS_VSN(r) dav_get_vsn_hooks(r)
736 #define DAV_GET_HOOKS_BINDING(r) dav_get_binding_hooks(r)
737 #define DAV_GET_HOOKS_SEARCH(r) dav_get_search_hooks(r)
738 
739 
740 /* --------------------------------------------------------------------
741 **
742 ** IF HEADER PROCESSING
743 **
744 ** Here is the definition of the If: header from RFC 2518, S9.4:
745 **
746 ** If = "If" ":" (1*No-tag-list | 1*Tagged-list)
747 ** No-tag-list = List
748 ** Tagged-list = Resource 1*List
749 ** Resource = Coded-URL
750 ** List = "(" 1*(["Not"](State-token | "[" entity-tag "]")) ")"
751 ** State-token = Coded-URL
752 ** Coded-URL = "<" absoluteURI ">" ; absoluteURI from RFC 2616
753 **
754 ** List corresponds to dav_if_state_list. No-tag-list corresponds to
755 ** dav_if_header with uri==NULL. Tagged-list corresponds to a sequence of
756 ** dav_if_header structures with (duplicate) uri==Resource -- one
757 ** dav_if_header per state_list. A second Tagged-list will start a new
758 ** sequence of dav_if_header structures with the new URI.
759 **
760 ** A summary of the semantics, mapped into our structures:
761 ** - Chained dav_if_headers: OR
762 ** - Chained dav_if_state_lists: AND
763 ** - NULL uri matches all resources
764 */
765 
766 typedef enum
767 {
770  dav_if_unknown /* the "unknown" state type; always matches false. */
772 
773 typedef struct dav_if_state_list
774 {
776 
778 #define DAV_IF_COND_NORMAL 0
779 #define DAV_IF_COND_NOT 1 /* "Not" was applied */
780 
781  const char *etag;
783 
786 
787 typedef struct dav_if_header
788 {
789  const char *uri;
793 
794  int dummy_header; /* used internally by the lock/etag validation */
795 } dav_if_header;
796 
797 typedef struct dav_locktoken_list
798 {
802 
803 DAV_DECLARE(dav_error *) dav_get_locktoken_list(request_rec *r,
805 
806 
807 /* --------------------------------------------------------------------
808 **
809 ** LIVE PROPERTY HANDLING
810 */
811 
812 /* opaque type for PROPPATCH rollback information */
814 
816 {
817  /*
818  ** Insert property information into a text block. The property to
819  ** insert is identified by the propid value. The information to insert
820  ** is identified by the "what" argument, as follows:
821  ** DAV_PROP_INSERT_NAME
822  ** property name, as an empty XML element
823  ** DAV_PROP_INSERT_VALUE
824  ** property name/value, as an XML element
825  ** DAV_PROP_INSERT_SUPPORTED
826  ** if the property is defined on the resource, then
827  ** a DAV:supported-live-property element, as defined
828  ** by the DeltaV extensions to RFC2518.
829  **
830  ** Providers should return DAV_PROP_INSERT_NOTDEF if the property is
831  ** known and not defined for this resource, so should be handled as a
832  ** dead property. If a provider recognizes, but does not support, a
833  ** property, and does not want it handled as a dead property, it should
834  ** return DAV_PROP_INSERT_NOTSUPP.
835  **
836  ** Returns one of DAV_PROP_INSERT_* based on what happened.
837  **
838  ** ### we may need more context... ie. the lock database
839  */
840  dav_prop_insert (*insert_prop)(const dav_resource *resource,
841  int propid, dav_prop_insert what,
843 
844  /*
845  ** Determine whether a given property is writable.
846  **
847  ** ### we may want a different semantic. i.e. maybe it should be
848  ** ### "can we write <value> into this property?"
849  **
850  ** Returns 1 if the live property can be written, 0 if read-only.
851  */
852  int (*is_writable)(const dav_resource *resource, int propid);
853 
854  /*
855  ** This member defines the set of namespace URIs that the provider
856  ** uses for its properties. When insert_all is called, it will be
857  ** passed a list of integers that map from indices into this list
858  ** to namespace IDs for output generation.
859  **
860  ** The last entry in this list should be a NULL value (sentinel).
861  */
862  const char * const * namespace_uris;
863 
864  /*
865  ** ### this is not the final design. we want an open-ended way for
866  ** ### liveprop providers to attach *new* properties. To this end,
867  ** ### we'll have a "give me a list of the props you define", a way
868  ** ### to check for a prop's existence, a way to validate a set/remove
869  ** ### of a prop, and a way to execute/commit/rollback that change.
870  */
871 
872  /*
873  ** Validate that the live property can be assigned a value, and that
874  ** the provided value is valid.
875  **
876  ** elem will point to the XML element that names the property. For
877  ** example:
878  ** <lp1:executable>T</lp1:executable>
879  **
880  ** The provider can access the cdata fields and the child elements
881  ** to extract the relevant pieces.
882  **
883  ** operation is one of DAV_PROP_OP_SET or _DELETE.
884  **
885  ** The provider may return a value in *context which will be passed
886  ** to each of the exec/commit/rollback functions. For example, this
887  ** may contain an internal value which has been processed from the
888  ** input element.
889  **
890  ** The provider must set defer_to_dead to true (non-zero) or false.
891  ** If true, then the set/remove is deferred to the dead property
892  ** database. Note: it will be set to zero on entry.
893  */
894  dav_error * (*patch_validate)(const dav_resource *resource,
895  const apr_xml_elem *elem,
896  int operation,
897  void **context,
898  int *defer_to_dead);
899 
900  /* ### doc... */
901  dav_error * (*patch_exec)(const dav_resource *resource,
902  const apr_xml_elem *elem,
903  int operation,
904  void *context,
905  dav_liveprop_rollback **rollback_ctx);
906 
907  /* ### doc... */
908  void (*patch_commit)(const dav_resource *resource,
909  int operation,
910  void *context,
911  dav_liveprop_rollback *rollback_ctx);
912 
913  /* ### doc... */
914  dav_error * (*patch_rollback)(const dav_resource *resource,
915  int operation,
916  void *context,
917  dav_liveprop_rollback *rollback_ctx);
918 
919  /*
920  ** If a provider needs a context to associate with this hooks structure,
921  ** then this field may be used. In most cases, it will just be NULL.
922  */
923  void *ctx;
924 };
925 
926 /*
927 ** dav_liveprop_spec: specify a live property
928 **
929 ** This structure is used as a standard way to determine if a particular
930 ** property is a live property. Its use is not part of the mandated liveprop
931 ** interface, but can be used by liveprop providers in conjunction with the
932 ** utility routines below.
933 **
934 ** spec->name == NULL is the defined end-sentinel for a list of specs.
935 */
936 typedef struct {
937  int ns; /* provider-local namespace index */
938  const char *name; /* name of the property */
939 
940  int propid; /* provider-local property ID */
941 
942  int is_writable; /* is the property writable? */
943 
945 
946 /*
947 ** dav_liveprop_group: specify a group of liveprops
948 **
949 ** This structure specifies a group of live properties, their namespaces,
950 ** and how to handle them.
951 */
952 typedef struct {
954  const char * const *namespace_uris;
956 
958 
959 /* ### docco */
960 DAV_DECLARE(int) dav_do_find_liveprop(const char *ns_uri, const char *name,
961  const dav_liveprop_group *group,
962  const dav_hooks_liveprop **hooks);
963 
964 /* ### docco */
965 DAV_DECLARE(long) dav_get_liveprop_info(int propid,
966  const dav_liveprop_group *group,
967  const dav_liveprop_spec **info);
968 
969 /* ### docco */
970 DAV_DECLARE(void) dav_register_liveprop_group(apr_pool_t *pool,
971  const dav_liveprop_group *group);
972 
973 /* ### docco */
974 DAV_DECLARE(long) dav_get_liveprop_ns_index(const char *uri);
975 
976 /* ### docco */
977 DAV_DECLARE(long) dav_get_liveprop_ns_count(void);
978 
979 /* ### docco */
980 DAV_DECLARE(void) dav_add_all_liveprop_xmlns(apr_pool_t *p,
982 
983 /*
984 ** The following three functions are part of mod_dav's internal handling
985 ** for the core WebDAV properties. They are not part of mod_dav's API.
986 */
987 DAV_DECLARE_NONSTD(int) dav_core_find_liveprop(
988  const dav_resource *resource,
989  const char *ns_uri,
990  const char *name,
991  const dav_hooks_liveprop **hooks);
992 DAV_DECLARE_NONSTD(void) dav_core_insert_all_liveprops(
993  request_rec *r,
994  const dav_resource *resource,
996  apr_text_header *phdr);
997 DAV_DECLARE_NONSTD(void) dav_core_register_uris(apr_pool_t *p);
998 
999 
1000 /*
1001 ** Standard WebDAV Property Identifiers
1002 **
1003 ** A live property provider does not need to use these; they are simply
1004 ** provided for convenience.
1005 **
1006 ** Property identifiers need to be unique within a given provider, but not
1007 ** *across* providers (note: this uniqueness constraint was different in
1008 ** older versions of mod_dav).
1009 **
1010 ** The identifiers start at 20000 to make it easier for providers to avoid
1011 ** conflicts with the standard properties. The properties are arranged
1012 ** alphabetically, and may be reordered from time to time (as properties
1013 ** are introduced).
1014 **
1015 ** NOTE: there is no problem with reordering (e.g. binary compat) since the
1016 ** identifiers are only used within a given provider, which would pick up
1017 ** the entire set of changes upon a recompile.
1018 */
1019 enum {
1021 
1022  /* Standard WebDAV properties (RFC 2518) */
1034 
1035  /* DeltaV properties (from the I-D (#14)) */
1074 
1076 };
1077 
1078 /*
1079 ** Property Identifier Registration
1080 **
1081 ** At the moment, mod_dav requires live property providers to ensure that
1082 ** each property returned has a unique value. For now, this is done through
1083 ** central registration (there are no known providers other than the default,
1084 ** so this remains manageable).
1085 **
1086 ** WARNING: the TEST ranges should never be "shipped".
1087 */
1088 #define DAV_PROPID_CORE 10000 /* ..10099. defined by mod_dav */
1089 #define DAV_PROPID_FS 10100 /* ..10299.
1090  mod_dav filesystem provider. */
1091 #define DAV_PROPID_TEST1 10300 /* ..10399 */
1092 #define DAV_PROPID_TEST2 10400 /* ..10499 */
1093 #define DAV_PROPID_TEST3 10500 /* ..10599 */
1094 /* Next: 10600 */
1095 
1096 
1097 /* --------------------------------------------------------------------
1098 **
1099 ** DATABASE FUNCTIONS
1100 */
1101 
1102 typedef struct dav_db dav_db;
1105 
1106 typedef struct {
1107  const char *ns; /* "" signals "no namespace" */
1108  const char *name;
1109 } dav_prop_name;
1110 
1111 /* hook functions to enable pluggable databases */
1113 {
1114  dav_error * (*open)(apr_pool_t *p, const dav_resource *resource, int ro,
1115  dav_db **pdb);
1116  void (*close)(dav_db *db);
1117 
1118  /*
1119  ** In bulk, define any namespaces that the values and their name
1120  ** elements may need.
1121  **
1122  ** Note: sometimes mod_dav will defer calling this until output_value
1123  ** returns found==1. If the output process needs the dav_xmlns_info
1124  ** filled for its work, then it will need to fill it on demand rather
1125  ** than depending upon this hook to fill in the structure.
1126  **
1127  ** Note: this will *always* be called during an output sequence. Thus,
1128  ** the provider may rely solely on using this to fill the xmlns info.
1129  */
1130  dav_error * (*define_namespaces)(dav_db *db, dav_xmlns_info *xi);
1131 
1132  /*
1133  ** Output the value from the database (i.e. add an element name and
1134  ** the value into *phdr). Set *found based on whether the name/value
1135  ** was found in the propdb.
1136  **
1137  ** Note: it is NOT an error for the key/value pair to not exist.
1138  **
1139  ** The dav_xmlns_info passed to define_namespaces() is also passed to
1140  ** each output_value() call so that namespaces can be added on-demand.
1141  ** It can also be used to look up prefixes or URIs during the output
1142  ** process.
1143  */
1144  dav_error * (*output_value)(dav_db *db, const dav_prop_name *name,
1145  dav_xmlns_info *xi,
1146  apr_text_header *phdr, int *found);
1147 
1148  /*
1149  ** Build a mapping from "global" namespaces (stored in apr_xml_*)
1150  ** into provider-local namespace identifiers.
1151  **
1152  ** This mapping should be done once per set of namespaces, and the
1153  ** resulting mapping should be passed into the store() hook function.
1154  **
1155  ** Note: usually, there is just a single document/namespaces for all
1156  ** elements passed. However, the generality of creating multiple
1157  ** mappings and passing them to store() is provided here.
1158  **
1159  ** Note: this is only in preparation for a series of store() calls.
1160  ** As a result, the propdb must be open for read/write access when
1161  ** this function is called.
1162  */
1163  dav_error * (*map_namespaces)(dav_db *db,
1165  dav_namespace_map **mapping);
1166 
1167  /*
1168  ** Store a property value for a given name. The value->combined field
1169  ** MUST be set for this call.
1170  **
1171  ** ### WARNING: current providers will quote the text within ELEM.
1172  ** ### this implies you can call this function only once with a given
1173  ** ### element structure (a second time will quote it again).
1174  */
1175  dav_error * (*store)(dav_db *db, const dav_prop_name *name,
1176  const apr_xml_elem *elem,
1177  dav_namespace_map *mapping);
1178 
1179  /* remove a given property */
1180  dav_error * (*remove)(dav_db *db, const dav_prop_name *name);
1181 
1182  /* returns 1 if the record specified by "key" exists; 0 otherwise */
1184 
1185  /*
1186  ** Iterate over the property names in the database.
1187  **
1188  ** iter->name.ns == iter->name.name == NULL when there are no more names.
1189  **
1190  ** Note: only one iteration may occur over the propdb at a time.
1191  */
1192  dav_error * (*first_name)(dav_db *db, dav_prop_name *pname);
1193  dav_error * (*next_name)(dav_db *db, dav_prop_name *pname);
1194 
1195  /*
1196  ** Rollback support: get rollback context, and apply it.
1197  **
1198  ** struct dav_deadprop_rollback is a provider-private structure; it
1199  ** should remember the name, and the name's old value (or the fact that
1200  ** the value was not present, and should be deleted if a rollback occurs).
1201  */
1202  dav_error * (*get_rollback)(dav_db *db, const dav_prop_name *name,
1203  dav_deadprop_rollback **prollback);
1204  dav_error * (*apply_rollback)(dav_db *db,
1205  dav_deadprop_rollback *rollback);
1206 
1207  /*
1208  ** If a provider needs a context to associate with this hooks structure,
1209  ** then this field may be used. In most cases, it will just be NULL.
1210  */
1211  void *ctx;
1212 };
1213 
1214 
1215 /* --------------------------------------------------------------------
1216 **
1217 ** LOCK FUNCTIONS
1218 */
1219 
1220 /* Used to represent a Timeout header of "Infinity" */
1221 #define DAV_TIMEOUT_INFINITE 0
1222 
1223 DAV_DECLARE(time_t) dav_get_timeout(request_rec *r);
1224 
1225 /*
1226 ** Opaque, provider-specific information for a lock database.
1227 */
1229 
1230 /*
1231 ** Opaque, provider-specific information for a lock record.
1232 */
1234 
1235 /*
1236 ** Lock database type. Lock providers are urged to implement a "lazy" open, so
1237 ** doing an "open" is cheap until something is actually needed from the DB.
1238 */
1239 typedef struct
1240 {
1241  const dav_hooks_locks *hooks; /* the hooks used for this lockdb */
1242  int ro; /* was it opened readonly? */
1243 
1244  dav_lockdb_private *info;
1245 
1246 } dav_lockdb;
1247 
1248 typedef enum {
1252 } dav_lock_scope;
1253 
1254 typedef enum {
1257 } dav_lock_type;
1258 
1259 typedef enum {
1260  DAV_LOCKREC_DIRECT, /* lock asserted on this resource */
1261  DAV_LOCKREC_INDIRECT, /* lock inherited from a parent */
1262  DAV_LOCKREC_INDIRECT_PARTIAL /* most info is not filled in */
1264 
1265 /*
1266 ** dav_lock: hold information about a lock on a resource.
1267 **
1268 ** This structure is used for both direct and indirect locks. A direct lock
1269 ** is a lock applied to a specific resource by the client. An indirect lock
1270 ** is one that is inherited from a parent resource by virtue of a non-zero
1271 ** Depth: header when the lock was applied.
1272 **
1273 ** mod_dav records both types of locks in the lock database, managing their
1274 ** addition/removal as resources are moved about the namespace.
1275 **
1276 ** Note that the lockdb is free to marshal this structure in any form that
1277 ** it likes.
1278 **
1279 ** For a "partial" lock, the <rectype> and <locktoken> fields must be filled
1280 ** in. All other (user) fields should be zeroed. The lock provider will
1281 ** usually fill in the <info> field, and the <next> field may be used to
1282 ** construct a list of partial locks.
1283 **
1284 ** The lock provider MUST use the info field to store a value such that a
1285 ** dav_lock structure can locate itself in the underlying lock database.
1286 ** This requirement is needed for refreshing: when an indirect dav_lock is
1287 ** refreshed, its reference to the direct lock does not specify the direct's
1288 ** resource, so the only way to locate the (refreshed, direct) lock in the
1289 ** database is to use the info field.
1290 **
1291 ** Note that <is_locknull> only refers to the resource where this lock was
1292 ** found.
1293 ** ### hrm. that says the abstraction is wrong. is_locknull may disappear.
1294 */
1295 typedef struct dav_lock
1296 {
1297  dav_lock_rectype rectype; /* type of lock record */
1298  int is_locknull; /* lock establishes a locknull resource */
1299 
1300  /* ### put the resource in here? */
1301 
1302  dav_lock_scope scope; /* scope of the lock */
1303  dav_lock_type type; /* type of lock */
1304  int depth; /* depth of the lock */
1305  time_t timeout; /* when the lock will timeout */
1306 
1307  const dav_locktoken *locktoken; /* the token that was issued */
1308 
1309  const char *owner; /* (XML) owner of the lock */
1310  const char *auth_user; /* auth'd username owning lock */
1311 
1312  dav_lock_private *info; /* private to the lockdb */
1313 
1314  struct dav_lock *next; /* for managing a list of locks */
1315 } dav_lock;
1316 
1317 /* Property-related public lock functions */
1318 DAV_DECLARE(const char *)dav_lock_get_activelock(request_rec *r,
1320  dav_buffer *pbuf);
1321 
1322 /* LockDB-related public lock functions */
1323 DAV_DECLARE(dav_error *) dav_lock_parse_lockinfo(request_rec *r,
1325  dav_lockdb *lockdb,
1326  const apr_xml_doc *doc,
1328 DAV_DECLARE(int) dav_unlock(request_rec *r,
1330  const dav_locktoken *locktoken);
1331 DAV_DECLARE(dav_error *) dav_add_lock(request_rec *r,
1332  const dav_resource *resource,
1333  dav_lockdb *lockdb, dav_lock *request,
1334  dav_response **response);
1335 DAV_DECLARE(dav_error *) dav_notify_created(request_rec *r,
1336  dav_lockdb *lockdb,
1337  const dav_resource *resource,
1338  int resource_state,
1339  int depth);
1340 
1341 DAV_DECLARE(dav_error*) dav_lock_query(dav_lockdb *lockdb,
1342  const dav_resource *resource,
1343  dav_lock **locks);
1344 
1345 DAV_DECLARE(dav_error *) dav_validate_request(request_rec *r,
1346  dav_resource *resource,
1347  int depth,
1348  dav_locktoken *locktoken,
1349  dav_response **response,
1350  int flags,
1351  dav_lockdb *lockdb);
1352 /*
1353 ** flags:
1354 ** 0x0F -- reserved for <dav_lock_scope> values
1355 **
1356 ** other flags, detailed below
1357 */
1358 #define DAV_VALIDATE_RESOURCE 0x0010 /* validate just the resource */
1359 #define DAV_VALIDATE_PARENT 0x0020 /* validate resource AND its parent */
1360 #define DAV_VALIDATE_ADD_LD 0x0040 /* add DAV:lockdiscovery into
1361  the 424 DAV:response */
1362 #define DAV_VALIDATE_USE_424 0x0080 /* return 424 status, not 207 */
1363 #define DAV_VALIDATE_IS_PARENT 0x0100 /* for internal use */
1364 #define DAV_VALIDATE_NO_MODIFY 0x0200 /* resource is not being modified
1365  so allow even if lock token
1366  is not provided */
1367 
1368 /* Lock-null related public lock functions */
1369 DAV_DECLARE(int) dav_get_resource_state(request_rec *r,
1370  const dav_resource *resource);
1371 
1372 /* Lock provider hooks. Locking is optional, so there may be no
1373  * lock provider for a given repository.
1374  */
1376 {
1377  /* Return the supportedlock property for a resource */
1378  const char * (*get_supportedlock)(
1379  const dav_resource *resource
1380  );
1381 
1382  /* Parse a lock token URI, returning a lock token object allocated
1383  * in the given pool.
1384  */
1385  dav_error * (*parse_locktoken)(
1386  apr_pool_t *p,
1387  const char *char_token,
1388  dav_locktoken **locktoken_p
1389  );
1390 
1391  /* Format a lock token object into a URI string, allocated in
1392  * the given pool.
1393  *
1394  * Always returns non-NULL.
1395  */
1396  const char * (*format_locktoken)(
1397  apr_pool_t *p,
1398  const dav_locktoken *locktoken
1399  );
1400 
1401  /* Compare two lock tokens.
1402  *
1403  * Result < 0 => lt1 < lt2
1404  * Result == 0 => lt1 == lt2
1405  * Result > 0 => lt1 > lt2
1406  */
1407  int (*compare_locktoken)(
1408  const dav_locktoken *lt1,
1409  const dav_locktoken *lt2
1410  );
1411 
1412  /* Open the provider's lock database.
1413  *
1414  * The provider may or may not use a "real" database for locks
1415  * (a lock could be an attribute on a resource, for example).
1416  *
1417  * The provider may choose to use the value of the DAVLockDB directive
1418  * (as returned by dav_get_lockdb_path()) to decide where to place
1419  * any storage it may need.
1420  *
1421  * The request storage pool should be associated with the lockdb,
1422  * so it can be used in subsequent operations.
1423  *
1424  * If ro != 0, only readonly operations will be performed.
1425  * If force == 0, the open can be "lazy"; no subsequent locking operations
1426  * may occur.
1427  * If force != 0, locking operations will definitely occur.
1428  */
1429  dav_error * (*open_lockdb)(
1430  request_rec *r,
1431  int ro,
1432  int force,
1433  dav_lockdb **lockdb
1434  );
1435 
1436  /* Indicates completion of locking operations */
1437  void (*close_lockdb)(
1439  );
1440 
1441  /* Take a resource out of the lock-null state. */
1442  dav_error * (*remove_locknull_state)(
1443  dav_lockdb *lockdb,
1444  const dav_resource *resource
1445  );
1446 
1447  /*
1448  ** Create a (direct) lock structure for the given resource. A locktoken
1449  ** will be created.
1450  **
1451  ** The lock provider may store private information into lock->info.
1452  */
1453  dav_error * (*create_lock)(dav_lockdb *lockdb,
1454  const dav_resource *resource,
1455  dav_lock **lock);
1456 
1457  /*
1458  ** Get the locks associated with the specified resource.
1459  **
1460  ** If resolve_locks is true (non-zero), then any indirect locks are
1461  ** resolved to their actual, direct lock (i.e. the reference to followed
1462  ** to the original lock).
1463  **
1464  ** The locks, if any, are returned as a linked list in no particular
1465  ** order. If no locks are present, then *locks will be NULL.
1466  */
1467  dav_error * (*get_locks)(dav_lockdb *lockdb,
1468  const dav_resource *resource,
1469  int calltype,
1470  dav_lock **locks);
1471 
1472 #define DAV_GETLOCKS_RESOLVED 0 /* resolve indirects to directs */
1473 #define DAV_GETLOCKS_PARTIAL 1 /* leave indirects partially filled */
1474 #define DAV_GETLOCKS_COMPLETE 2 /* fill out indirect locks */
1475 
1476  /*
1477  ** Find a particular lock on a resource (specified by its locktoken).
1478  **
1479  ** *lock will be set to NULL if the lock is not found.
1480  **
1481  ** Note that the provider can optimize the unmarshalling -- only one
1482  ** lock (or none) must be constructed and returned.
1483  **
1484  ** If partial_ok is true (non-zero), then an indirect lock can be
1485  ** partially filled in. Otherwise, another lookup is done and the
1486  ** lock structure will be filled out as a DAV_LOCKREC_INDIRECT.
1487  */
1488  dav_error * (*find_lock)(dav_lockdb *lockdb,
1489  const dav_resource *resource,
1490  const dav_locktoken *locktoken,
1491  int partial_ok,
1492  dav_lock **lock);
1493 
1494  /*
1495  ** Quick test to see if the resource has *any* locks on it.
1496  **
1497  ** This is typically used to determine if a non-existent resource
1498  ** has a lock and is (therefore) a locknull resource.
1499  **
1500  ** WARNING: this function may return TRUE even when timed-out locks
1501  ** exist (i.e. it may not perform timeout checks).
1502  */
1503  dav_error * (*has_locks)(dav_lockdb *lockdb,
1504  const dav_resource *resource,
1505  int *locks_present);
1506 
1507  /*
1508  ** Append the specified lock(s) to the set of locks on this resource.
1509  **
1510  ** If "make_indirect" is true (non-zero), then the specified lock(s)
1511  ** should be converted to an indirect lock (if it is a direct lock)
1512  ** before appending. Note that the conversion to an indirect lock does
1513  ** not alter the passed-in lock -- the change is internal the
1514  ** append_locks function.
1515  **
1516  ** Multiple locks are specified using the lock->next links.
1517  */
1518  dav_error * (*append_locks)(dav_lockdb *lockdb,
1519  const dav_resource *resource,
1520  int make_indirect,
1521  const dav_lock *lock);
1522 
1523  /*
1524  ** Remove any lock that has the specified locktoken.
1525  **
1526  ** If locktoken == NULL, then ALL locks are removed.
1527  */
1528  dav_error * (*remove_lock)(dav_lockdb *lockdb,
1529  const dav_resource *resource,
1530  const dav_locktoken *locktoken);
1531 
1532  /*
1533  ** Refresh all locks, found on the specified resource, which has a
1534  ** locktoken in the provided list.
1535  **
1536  ** If the lock is indirect, then the direct lock is referenced and
1537  ** refreshed.
1538  **
1539  ** Each lock that is updated is returned in the <locks> argument.
1540  ** Note that the locks will be fully resolved.
1541  */
1542  dav_error * (*refresh_locks)(dav_lockdb *lockdb,
1543  const dav_resource *resource,
1544  const dav_locktoken_list *ltl,
1545  time_t new_time,
1546  dav_lock **locks);
1547 
1548  /*
1549  ** Look up the resource associated with a particular locktoken.
1550  **
1551  ** The search begins at the specified <start_resource> and the lock
1552  ** specified by <locktoken>.
1553  **
1554  ** If the resource/token specifies an indirect lock, then the direct
1555  ** lock will be looked up, and THAT resource will be returned. In other
1556  ** words, this function always returns the resource where a particular
1557  ** lock (token) was asserted.
1558  **
1559  ** NOTE: this function pointer is allowed to be NULL, indicating that
1560  ** the provider does not support this type of functionality. The
1561  ** caller should then traverse up the repository hierarchy looking
1562  ** for the resource defining a lock with this locktoken.
1563  */
1564  dav_error * (*lookup_resource)(dav_lockdb *lockdb,
1565  const dav_locktoken *locktoken,
1566  const dav_resource *start_resource,
1567  const dav_resource **resource);
1568 
1569  /*
1570  ** If a provider needs a context to associate with this hooks structure,
1571  ** then this field may be used. In most cases, it will just be NULL.
1572  */
1573  void *ctx;
1574 };
1575 
1576 /* what types of resources can be discovered by dav_get_resource_state() */
1577 #define DAV_RESOURCE_LOCK_NULL 10 /* resource lock-null */
1578 #define DAV_RESOURCE_NULL 11 /* resource null */
1579 #define DAV_RESOURCE_EXISTS 12 /* resource exists */
1580 #define DAV_RESOURCE_ERROR 13 /* an error occurred */
1581 
1582 
1583 /* --------------------------------------------------------------------
1584 **
1585 ** PROPERTY HANDLING
1586 */
1587 
1588 typedef struct dav_propdb dav_propdb;
1589 
1590 
1591 DAV_DECLARE(dav_error *) dav_open_propdb(
1592  request_rec *r,
1593  dav_lockdb *lockdb,
1594  const dav_resource *resource,
1595  int ro,
1597  dav_propdb **propdb);
1598 
1599 DAV_DECLARE(dav_error *) dav_popen_propdb(
1600  apr_pool_t *p,
1601  request_rec *r,
1602  dav_lockdb *lockdb,
1603  const dav_resource *resource,
1604  int ro,
1605  apr_array_header_t *ns_xlate,
1606  dav_propdb **propdb);
1607 
1608 
1609 DAV_DECLARE(void) dav_close_propdb(dav_propdb *db);
1610 
1611 DAV_DECLARE(dav_get_props_result) dav_get_props(
1612  dav_propdb *db,
1613  apr_xml_doc *doc);
1614 
1615 DAV_DECLARE(dav_get_props_result) dav_get_allprops(
1616  dav_propdb *db,
1618 
1619 DAV_DECLARE(void) dav_get_liveprop_supported(
1620  dav_propdb *propdb,
1621  const char *ns_uri,
1622  const char *propname,
1624 
1625 /*
1626 ** 3-phase property modification.
1627 **
1628 ** 1) validate props. readable? unlocked? ACLs allow access?
1629 ** 2) execute operation (set/delete)
1630 ** 3) commit or rollback
1631 **
1632 ** ### eventually, auth must be available. a ref to the request_rec (which
1633 ** ### contains the auth info) should be in the shared context struct.
1634 **
1635 ** Each function may alter the error values and information contained within
1636 ** the context record. This should be done as an "increasing" level of
1637 ** error, rather than overwriting any previous error.
1638 **
1639 ** Note that commit() cannot generate errors. It should simply free the
1640 ** rollback information.
1641 **
1642 ** rollback() may generate additional errors because the rollback operation
1643 ** can sometimes fail(!).
1644 **
1645 ** The caller should allocate an array of these, one per operation. It should
1646 ** be zero-initialized, then the db, operation, and prop fields should be
1647 ** filled in before calling dav_prop_validate. Note that the set/delete
1648 ** operations are order-dependent. For a given (logical) context, the same
1649 ** pointer must be passed to each phase.
1650 **
1651 ** error_type is an internal value, but will have the same numeric value
1652 ** for each possible "desc" value. This allows the caller to group the
1653 ** descriptions via the error_type variable, rather than through string
1654 ** comparisons. Note that "status" does not provide enough granularity to
1655 ** differentiate/group the "desc" values.
1656 **
1657 ** Note that the propdb will maintain some (global) context across all
1658 ** of the property change contexts. This implies that you can have only
1659 ** one open transaction per propdb.
1660 */
1661 typedef struct dav_prop_ctx
1662 {
1664 
1665  apr_xml_elem *prop; /* property to affect */
1666 
1668 #define DAV_PROP_OP_SET 1 /* set a property value */
1669 #define DAV_PROP_OP_DELETE 2 /* delete a prop value */
1670 /* ### add a GET? */
1671 
1672  /* private items to the propdb */
1675  struct dav_rollback_item *rollback; /* optional rollback info */
1676 
1677  dav_error *err; /* error (if any) */
1678 
1679  /* private to mod_dav.c */
1681 
1682 } dav_prop_ctx;
1683 
1684 DAV_DECLARE_NONSTD(void) dav_prop_validate(dav_prop_ctx *ctx);
1685 DAV_DECLARE_NONSTD(void) dav_prop_exec(dav_prop_ctx *ctx);
1686 DAV_DECLARE_NONSTD(void) dav_prop_commit(dav_prop_ctx *ctx);
1687 DAV_DECLARE_NONSTD(void) dav_prop_rollback(dav_prop_ctx *ctx);
1688 
1689 #define DAV_PROP_CTX_HAS_ERR(dpc) ((dpc).err && (dpc).err->status >= 300)
1690 
1691 
1692 /* --------------------------------------------------------------------
1693 **
1694 ** WALKER STRUCTURE
1695 */
1696 
1697 enum {
1698  DAV_CALLTYPE_MEMBER = 1, /* called for a member resource */
1699  DAV_CALLTYPE_COLLECTION, /* called for a collection */
1700  DAV_CALLTYPE_LOCKNULL /* called for a locknull resource */
1701 };
1702 
1703 typedef struct
1704 {
1705  /* the client-provided context */
1706  void *walk_ctx;
1707 
1708  /* pool to use for allocations in the callback */
1710 
1711  /* the current resource */
1713 
1714  /* OUTPUT: add responses to this */
1715  dav_response *response;
1716 
1718 
1719 typedef struct
1720 {
1722 #define DAV_WALKTYPE_AUTH 0x0001 /* limit to authorized files */
1723 #define DAV_WALKTYPE_NORMAL 0x0002 /* walk normal files */
1724 #define DAV_WALKTYPE_LOCKNULL 0x0004 /* walk locknull resources */
1725 
1726  /* callback function and a client context for the walk */
1727  dav_error * (*func)(dav_walk_resource *wres, int calltype);
1728  void *walk_ctx;
1729 
1730  /* what pool to use for allocations needed by walk logic */
1732 
1733  /* beginning root of the walk */
1735 
1736  /* lock database to enable walking LOCKNULL resources */
1738 
1739 } dav_walk_params;
1740 
1741 /* directory tree walking context */
1742 typedef struct dav_walker_ctx
1743 {
1744  /* input: */
1746 
1747 
1748  /* ### client data... phasing out this big glom */
1749 
1750  /* this brigade buffers data being sent to r->output_filters */
1752 
1753  /* a scratch pool, used to stream responses and iteratively cleared. */
1755 
1756  request_rec *r; /* original request */
1757 
1758  /* for PROPFIND operations */
1761 #define DAV_PROPFIND_IS_ALLPROP 1
1762 #define DAV_PROPFIND_IS_PROPNAME 2
1763 #define DAV_PROPFIND_IS_PROP 3
1764 
1765  apr_text *propstat_404; /* (cached) propstat giving a 404 error */
1766 
1767  const dav_if_header *if_header; /* for validation */
1768  const dav_locktoken *locktoken; /* for UNLOCK */
1769  const dav_lock *lock; /* for LOCK */
1770  int skip_root; /* for dav_inherit_locks() */
1771 
1772  int flags;
1773 
1774  dav_buffer work_buf; /* for dav_validate_request() */
1775 
1776 } dav_walker_ctx;
1777 
1778 DAV_DECLARE(void) dav_add_response(dav_walk_resource *wres,
1779  int status,
1781 
1782 
1783 /* --------------------------------------------------------------------
1784 **
1785 ** "STREAM" STRUCTURE
1786 **
1787 ** mod_dav uses this abstraction for interacting with the repository
1788 ** while fetching/storing resources. mod_dav views resources as a stream
1789 ** of bytes.
1790 **
1791 ** Note that the structure is opaque -- it is private to the repository
1792 ** that created the stream in the repository's "open" function.
1793 **
1794 ** ### THIS STUFF IS GOING AWAY ... GET/read requests are handled by
1795 ** ### having the provider jam stuff straight into the filter stack.
1796 ** ### this is only left for handling PUT/write requests.
1797 */
1798 
1799 typedef struct dav_stream dav_stream;
1800 
1801 typedef enum {
1802  DAV_MODE_WRITE_TRUNC, /* truncate and open for writing */
1803  DAV_MODE_WRITE_SEEKABLE /* open for writing; random access */
1804 } dav_stream_mode;
1805 
1806 
1807 /* --------------------------------------------------------------------
1808 **
1809 ** REPOSITORY FUNCTIONS
1810 */
1811 
1812 /* Repository provider hooks */
1814 {
1815  /* Flag for whether repository requires special GET handling.
1816  * If resources in the repository are not visible in the
1817  * filesystem location which URLs map to, then special handling
1818  * is required to first fetch a resource from the repository,
1819  * respond to the GET request, then free the resource copy.
1820  */
1822 
1823  /* Get a resource descriptor for the URI in a request. A descriptor
1824  * should always be returned even if the resource does not exist. This
1825  * repository has been identified as handling the resource given by
1826  * the URI, so an answer must be given. If there is a problem with the
1827  * URI or accessing the resource or whatever, then an error should be
1828  * returned.
1829  *
1830  * root_dir:
1831  * the root of the directory for which this repository is configured.
1832  *
1833  * label:
1834  * if a Label: header is present (and allowed), this is the label
1835  * to use to identify a version resource from the resource's
1836  * corresponding version history. Otherwise, it will be NULL.
1837  *
1838  * use_checked_in:
1839  * use the DAV:checked-in property of the resource identified by the
1840  * Request-URI to identify and return a version resource
1841  *
1842  * The provider may associate the request storage pool with the resource
1843  * (in the resource->pool field), to use in other operations on that
1844  * resource.
1845  */
1846  dav_error * (*get_resource)(
1847  request_rec *r,
1848  const char *root_dir,
1849  const char *label,
1850  int use_checked_in,
1852  );
1853 
1854  /* Get a resource descriptor for the parent of the given resource.
1855  * The resources need not exist. NULL is returned if the resource
1856  * is the root collection.
1857  *
1858  * An error should be returned only if there is a fatal error in
1859  * fetching information about the parent resource.
1860  */
1861  dav_error * (*get_parent_resource)(
1862  const dav_resource *resource,
1863  dav_resource **parent_resource
1864  );
1865 
1866  /* Determine whether two resource descriptors refer to the same resource.
1867  *
1868  * Result != 0 => the resources are the same.
1869  */
1871  const dav_resource *res1,
1872  const dav_resource *res2
1873  );
1874 
1875  /* Determine whether one resource is a parent (immediate or otherwise)
1876  * of another.
1877  *
1878  * Result != 0 => res1 is a parent of res2.
1879  */
1881  const dav_resource *res1,
1882  const dav_resource *res2
1883  );
1884 
1885  /*
1886  ** Open a stream for this resource, using the specified mode. The
1887  ** stream will be returned in *stream.
1888  */
1889  dav_error * (*open_stream)(const dav_resource *resource,
1890  dav_stream_mode mode,
1891  dav_stream **stream);
1892 
1893  /*
1894  ** Close the specified stream.
1895  **
1896  ** mod_dav will (ideally) make sure to call this. For safety purposes,
1897  ** a provider should (ideally) register a cleanup function with the
1898  ** request pool to get this closed and cleaned up.
1899  **
1900  ** Note the possibility of an error from the close -- it is entirely
1901  ** feasible that the close does a "commit" of some kind, which can
1902  ** produce an error.
1903  **
1904  ** commit should be TRUE (non-zero) or FALSE (0) if the stream was
1905  ** opened for writing. This flag states whether to retain the file
1906  ** or not.
1907  ** Note: the commit flag is ignored for streams opened for reading.
1908  */
1909  dav_error * (*close_stream)(dav_stream *stream, int commit);
1910 
1911  /*
1912  ** Write data to the stream.
1913  **
1914  ** All of the bytes must be written, or an error should be returned.
1915  */
1916  dav_error * (*write_stream)(dav_stream *stream,
1917  const void *buf, apr_size_t bufsize);
1918 
1919  /*
1920  ** Seek to an absolute position in the stream. This is used to support
1921  ** Content-Range in a GET/PUT.
1922  **
1923  ** NOTE: if this function is NULL (which is allowed), then any
1924  ** operations using Content-Range will be refused.
1925  */
1926  dav_error * (*seek_stream)(dav_stream *stream, apr_off_t abs_position);
1927 
1928  /*
1929  ** If a GET is processed using a stream (open_stream, read_stream)
1930  ** rather than via a sub-request (on get_pathname), then this function
1931  ** is used to provide the repository with a way to set the headers
1932  ** in the response.
1933  **
1934  ** This function may be called without a following deliver(), to
1935  ** handle a HEAD request.
1936  **
1937  ** This may be NULL if handle_get is FALSE.
1938  */
1939  dav_error * (*set_headers)(request_rec *r,
1940  const dav_resource *resource);
1941 
1942  /*
1943  ** The provider should deliver the resource into the request's output
1944  ** filter stack. Basically, this is the response to the GET method.
1945  **
1946  ** Note that this is called for all resources, including collections.
1947  ** The provider should determine what has content to deliver or not.
1948  **
1949  ** set_headers will be called prior to this function, allowing the
1950  ** provider to set the appropriate response headers.
1951  **
1952  ** This may be NULL if handle_get is FALSE.
1953  ** ### maybe toss handle_get and just use this function as the marker
1954  **
1955  ** API ISSUE: don't use the passed-in 'output' filter.
1956  **
1957  ** Instead, generate the response into the output filter stack for the
1958  ** request (r->output_filters). An implementation can use the request_rec
1959  ** that was passed to get_resource() for this purpose. Using 'output'
1960  ** filter for the response can cause unbounded memory usage.
1961  **
1962  ** See https://mail-archives.apache.org/mod_mbox/httpd-dev/201608.mbox/%3C20160822151917.GA22369%40redhat.com%3E
1963  */
1964  dav_error * (*deliver)(const dav_resource *resource,
1965  ap_filter_t *output);
1966 
1967  /* Create a collection resource. The resource must not already exist.
1968  *
1969  * Result == NULL if the collection was created successfully. Also, the
1970  * resource object is updated to reflect that the resource exists, and
1971  * is a collection.
1972  */
1973  dav_error * (*create_collection)(
1975  );
1976 
1977  /* Copy one resource to another. The destination may exist, if it is
1978  * versioned.
1979  * Handles both files and collections. Properties are copied as well.
1980  * If the destination exists and is versioned, the provider must update
1981  * the destination to have identical content to the source,
1982  * recursively for collections.
1983  * The depth argument is ignored for a file, and can be either 0 or
1984  * DAV_INFINITY for a collection.
1985  * If an error occurs in a child resource, then the return value is
1986  * non-NULL, and *response is set to a multistatus response.
1987  * If the copy is successful, the dst resource object is
1988  * updated to reflect that the resource exists.
1989  */
1990  dav_error * (*copy_resource)(
1991  const dav_resource *src,
1992  dav_resource *dst,
1993  int depth,
1994  dav_response **response
1995  );
1996 
1997  /* Move one resource to another. The destination must not exist.
1998  * Handles both files and collections. Properties are moved as well.
1999  * If an error occurs in a child resource, then the return value is
2000  * non-NULL, and *response is set to a multistatus response.
2001  * If the move is successful, the src and dst resource objects are
2002  * updated to reflect that the source no longer exists, and the
2003  * destination does.
2004  */
2005  dav_error * (*move_resource)(
2006  dav_resource *src,
2007  dav_resource *dst,
2008  dav_response **response
2009  );
2010 
2011  /* Remove a resource. Handles both files and collections.
2012  * Removes any associated properties as well.
2013  * If an error occurs in a child resource, then the return value is
2014  * non-NULL, and *response is set to a multistatus response.
2015  * If the delete is successful, the resource object is updated to
2016  * reflect that the resource no longer exists.
2017  */
2018  dav_error * (*remove_resource)(
2020  dav_response **response
2021  );
2022 
2023  /* Walk a resource hierarchy.
2024  *
2025  * Iterates over the resource hierarchy specified by params->root.
2026  * Control of the walk and the callback are specified by 'params'.
2027  *
2028  * An error may be returned. *response will contain multistatus
2029  * responses (if any) suitable for the body of the error. It is also
2030  * possible to return NULL, yet still have multistatus responses.
2031  * In this case, typically the caller should return a 207 (Multistatus)
2032  * and the responses (in the body) as the HTTP response.
2033  */
2034  dav_error * (*walk)(const dav_walk_params *params, int depth,
2035  dav_response **response);
2036 
2037  /* Get the entity tag for a resource */
2038  const char * (*getetag)(const dav_resource *resource);
2039 
2040  /*
2041  ** If a provider needs a context to associate with this hooks structure,
2042  ** then this field may be used. In most cases, it will just be NULL.
2043  */
2044  void *ctx;
2045 
2046  /* Get the request rec for a resource */
2047  request_rec * (*get_request_rec)(const dav_resource *resource);
2048 
2049  /* Get the pathname for a resource */
2050  const char * (*get_pathname)(const dav_resource *resource);
2051 };
2052 
2053 
2054 /* --------------------------------------------------------------------
2055 **
2056 ** VERSIONING FUNCTIONS
2057 */
2058 
2059 
2060 /* dav_add_vary_header
2061  *
2062  * If there were any headers in the request which require a Vary header
2063  * in the response, add it.
2064  */
2065 DAV_DECLARE(void) dav_add_vary_header(request_rec *in_req,
2067  const dav_resource *resource);
2068 
2069 /*
2070 ** Flags specifying auto-versioning behavior, returned by
2071 ** the auto_versionable hook. The value returned depends
2072 ** on both the state of the resource and the value of the
2073 ** DAV:auto-versioning property for the resource.
2074 **
2075 ** If the resource does not exist (null or lock-null),
2076 ** DAV_AUTO_VERSION_ALWAYS causes creation of a new version-controlled resource
2077 **
2078 ** If the resource is checked in,
2079 ** DAV_AUTO_VERSION_ALWAYS causes it to be checked out always,
2080 ** DAV_AUTO_VERSION_LOCKED causes it to be checked out only when locked
2081 **
2082 ** If the resource is checked out,
2083 ** DAV_AUTO_VERSION_ALWAYS causes it to be checked in always,
2084 ** DAV_AUTO_VERSION_LOCKED causes it to be checked in when unlocked
2085 ** (note: a provider should allow auto-checkin only for resources which
2086 ** were automatically checked out)
2087 **
2088 ** In all cases, DAV_AUTO_VERSION_NEVER results in no auto-versioning behavior.
2089 */
2090 typedef enum {
2095 
2096 /*
2097 ** This structure is used to record what auto-versioning operations
2098 ** were done to make a resource writable, so that they can be undone
2099 ** at the end of a request.
2100 */
2101 typedef struct {
2102  int resource_versioned; /* 1 => resource was auto-version-controlled */
2103  int resource_checkedout; /* 1 => resource was auto-checked-out */
2104  int parent_checkedout; /* 1 => parent was auto-checked-out */
2105  dav_resource *parent_resource; /* parent resource, if it was needed */
2107 
2108 /* Ensure that a resource is writable. If there is no versioning
2109  * provider, then this is essentially a no-op. Versioning repositories
2110  * require explicit resource creation and checkout before they can
2111  * be written to. If a new resource is to be created, or an existing
2112  * resource deleted, the parent collection must be checked out as well.
2113  *
2114  * Set the parent_only flag to only make the parent collection writable.
2115  * Otherwise, both parent and child are made writable as needed. If the
2116  * child does not exist, then a new versioned resource is created and
2117  * checked out.
2118  *
2119  * If auto-versioning is not enabled for a versioned resource, then an error is
2120  * returned, since the resource cannot be modified.
2121  *
2122  * The dav_auto_version_info structure is filled in with enough information
2123  * to restore both parent and child resources to the state they were in
2124  * before the auto-versioning operations occurred.
2125  */
2126 DAV_DECLARE(dav_error *) dav_auto_checkout(
2127  request_rec *r,
2128  dav_resource *resource,
2129  int parent_only,
2131 
2132 /* Revert the writability of resources back to what they were
2133  * before they were modified. If undo == 0, then the resource
2134  * modifications are maintained (i.e. they are checked in).
2135  * If undo != 0, then resource modifications are discarded
2136  * (i.e. they are unchecked out).
2137  *
2138  * Set the unlock flag to indicate that the resource is about
2139  * to be unlocked; it will be checked in if the resource
2140  * auto-versioning property indicates it should be. In this case,
2141  * av_info is ignored, so it can be NULL.
2142  *
2143  * The resource argument may be NULL if only the parent resource
2144  * was checked out (i.e. the parent_only was != 0 in the
2145  * dav_auto_checkout call).
2146  */
2147 DAV_DECLARE(dav_error *) dav_auto_checkin(
2148  request_rec *r,
2149  dav_resource *resource,
2150  int undo,
2151  int unlock,
2152  dav_auto_version_info *av_info);
2153 
2154 /*
2155 ** This structure is used to describe available reports
2156 **
2157 ** "nmspace" should be valid XML and URL-quoted. mod_dav will place
2158 ** double-quotes around it and use it in an xmlns declaration.
2159 */
2160 typedef struct {
2161  const char *nmspace; /* namespace of the XML report element */
2162  const char *name; /* element name for the XML report */
2163 } dav_report_elem;
2164 
2165 
2166 /* Versioning provider hooks */
2168 {
2169  /*
2170  ** MANDATORY HOOKS
2171  ** The following hooks are mandatory for all versioning providers;
2172  ** they define the functionality needed to implement "core" versioning.
2173  */
2174 
2175  /* Return supported versioning options.
2176  * Each dav_text item in the list will be returned as a separate
2177  * DAV header. Providers are advised to limit the length of an
2178  * individual text item to 63 characters, to conform to the limit
2179  * used by MS Web Folders.
2180  */
2182 
2183  /* Get the value of a specific option for an OPTIONS request.
2184  * The option being requested is given by the parsed XML
2185  * element object "elem". The value of the option should be
2186  * appended to the "option" text object.
2187  */
2188  dav_error * (*get_option)(const dav_resource *resource,
2189  const apr_xml_elem *elem,
2190  apr_text_header *option);
2191 
2192  /* Determine whether a non-versioned (or non-existent) resource
2193  * is versionable. Returns != 0 if resource can be versioned.
2194  */
2196 
2197  /* Determine whether auto-versioning is enabled for a resource
2198  * (which may not exist, or may not be versioned). If the resource
2199  * is a checked-out resource, the provider must only enable
2200  * auto-checkin if the resource was automatically checked out.
2201  *
2202  * The value returned depends on both the state of the resource
2203  * and the value of its DAV:auto-version property. See the description
2204  * of the dav_auto_version enumeration above for the details.
2205  */
2207 
2208  /* Put a resource under version control. If the resource already
2209  * exists unversioned, then it becomes the initial version of the
2210  * new version history, and it is replaced by a version selector
2211  * which targets the new version.
2212  *
2213  * If the resource does not exist, then a new version-controlled
2214  * resource is created which either targets an existing version (if the
2215  * "target" argument is not NULL), or the initial, empty version
2216  * in a new history resource (if the "target" argument is NULL).
2217  *
2218  * If successful, the resource object state is updated appropriately
2219  * (that is, changed to refer to the new version-controlled resource).
2220  */
2221  dav_error * (*vsn_control)(dav_resource *resource,
2222  const char *target);
2223 
2224  /* Checkout a resource. If successful, the resource
2225  * object state is updated appropriately.
2226  *
2227  * The auto_checkout flag will be set if this checkout is being
2228  * done automatically, as part of some method which modifies
2229  * the resource. The provider must remember that the resource
2230  * was automatically checked out, so it can determine whether it
2231  * can be automatically checked in. (Auto-checkin should only be
2232  * enabled for resources which were automatically checked out.)
2233  *
2234  * If the working resource has a different URL from the
2235  * target resource, a dav_resource descriptor is returned
2236  * for the new working resource. Otherwise, the original
2237  * resource descriptor will refer to the working resource.
2238  * The working_resource argument can be NULL if the caller
2239  * is not interested in the working resource.
2240  *
2241  * If the client has specified DAV:unreserved or DAV:fork-ok in the
2242  * checkout request, then the corresponding flags are set. If
2243  * DAV:activity-set has been specified, then create_activity is set
2244  * if DAV:new was specified; otherwise, the DAV:href elements' CDATA
2245  * (the actual href text) is passed in the "activities" array (each
2246  * element of the array is a const char *). activities will be NULL
2247  * no DAV:activity-set was provided or when create_activity is set.
2248  */
2250  int auto_checkout,
2251  int is_unreserved, int is_fork_ok,
2252  int create_activity,
2253  apr_array_header_t *activities,
2254  dav_resource **working_resource);
2255 
2256  /* Uncheckout a checked-out resource. If successful, the resource
2257  * object state is updated appropriately.
2258  */
2259  dav_error * (*uncheckout)(dav_resource *resource);
2260 
2261  /* Checkin a checked-out resource. If successful, the resource
2262  * object state is updated appropriately, and the
2263  * version_resource descriptor will refer to the new version.
2264  * The version_resource argument can be NULL if the caller
2265  * is not interested in the new version resource.
2266  *
2267  * If the client has specified DAV:keep-checked-out in the checkin
2268  * request, then the keep_checked_out flag is set. The provider
2269  * should create a new version, but keep the resource in the
2270  * checked-out state.
2271  */
2273  int keep_checked_out,
2274  dav_resource **version_resource);
2275 
2276  /*
2277  ** Return the set of reports available at this resource.
2278  **
2279  ** An array of report elements should be returned, with an end-marker
2280  ** element containing namespace==NULL. The value of the
2281  ** DAV:supported-report-set property will be constructed and
2282  ** returned.
2283  */
2284  dav_error * (*avail_reports)(const dav_resource *resource,
2285  const dav_report_elem **reports);
2286 
2287  /*
2288  ** Determine whether a Label header can be used
2289  ** with a particular report. The dav_xml_doc structure
2290  ** contains the parsed report request body.
2291  ** Returns 0 if the Label header is not allowed.
2292  */
2294 
2295  /*
2296  ** Generate a report on a resource. Since a provider is free
2297  ** to define its own reports, and the value of request headers
2298  ** may affect the interpretation of a report, the request record
2299  ** must be passed to this routine.
2300  **
2301  ** The dav_xml_doc structure contains the parsed report request
2302  ** body. The report response should be generated into the specified
2303  ** output filter.
2304  **
2305  ** If an error occurs, and a response has not yet been generated,
2306  ** then an error can be returned from this function. mod_dav will
2307  ** construct an appropriate error response. Once some output has
2308  ** been placed into the filter, however, the provider should not
2309  ** return an error -- there is no way that mod_dav can deliver it
2310  ** properly.
2311  **
2312  ** ### maybe we need a way to signal an error anyways, and then
2313  ** ### apache can abort the connection?
2314  **
2315  ** API ISSUE: don't use the passed-in 'output' filter.
2316  **
2317  ** Instead, generate the response into the output filter stack for the
2318  ** request (r->output_filters). An implementation can use the request_rec
2319  ** that was passed to get_resource() for this purpose. Using 'output'
2320  ** filter for the response can cause unbounded memory usage.
2321  **
2322  ** See https://mail-archives.apache.org/mod_mbox/httpd-dev/201608.mbox/%3C20160822151917.GA22369%40redhat.com%3E
2323  */
2324  dav_error * (*deliver_report)(request_rec *r,
2325  const dav_resource *resource,
2326  const apr_xml_doc *doc,
2327  ap_filter_t *output);
2328 
2329  /*
2330  ** OPTIONAL HOOKS
2331  ** The following hooks are optional; if not defined, then the
2332  ** corresponding protocol methods will be unsupported.
2333  */
2334 
2335  /*
2336  ** Set the state of a checked-in version-controlled resource.
2337  **
2338  ** If the request specified a version, the version resource
2339  ** represents that version. If the request specified a label,
2340  ** then "version" is NULL, and "label" is the label.
2341  **
2342  ** The depth argument is ignored for a file, and can be 0, 1, or
2343  ** DAV_INFINITY for a collection. The depth argument only applies
2344  ** with a label, not a version.
2345  **
2346  ** If an error occurs in a child resource, then the return value is
2347  ** non-NULL, and *response is set to a multistatus response.
2348  **
2349  ** This hook is optional; if not defined, then the UPDATE method
2350  ** will not be supported.
2351  */
2352  dav_error * (*update)(const dav_resource *resource,
2353  const dav_resource *version,
2354  const char *label,
2355  int depth,
2356  dav_response **response);
2357 
2358  /*
2359  ** Add a label to a version. The resource is either a specific
2360  ** version, or a version selector, in which case the label should
2361  ** be added to the current target of the version selector. The
2362  ** version selector cannot be checked out.
2363  **
2364  ** If replace != 0, any existing label by the same name is
2365  ** effectively deleted first. Otherwise, it is an error to
2366  ** attempt to add a label which already exists on some version
2367  ** of the same history resource.
2368  **
2369  ** This hook is optional; if not defined, then the LABEL method
2370  ** will not be supported. If it is defined, then the remove_label
2371  ** hook must be defined also.
2372  */
2373  dav_error * (*add_label)(const dav_resource *resource,
2374  const char *label,
2375  int replace);
2376 
2377  /*
2378  ** Remove a label from a version. The resource is either a specific
2379  ** version, or a version selector, in which case the label should
2380  ** be added to the current target of the version selector. The
2381  ** version selector cannot be checked out.
2382  **
2383  ** It is an error if no such label exists on the specified version.
2384  **
2385  ** This hook is optional, but if defined, the add_label hook
2386  ** must be defined also.
2387  */
2388  dav_error * (*remove_label)(const dav_resource *resource,
2389  const char *label);
2390 
2391  /*
2392  ** Determine whether a null resource can be created as a workspace.
2393  ** The provider may restrict workspaces to certain locations.
2394  ** Returns 0 if the resource cannot be a workspace.
2395  **
2396  ** This hook is optional; if the provider does not support workspaces,
2397  ** it should be set to NULL.
2398  */
2400 
2401  /*
2402  ** Create a workspace resource. The resource must not already
2403  ** exist. Any <DAV:mkworkspace> element is passed to the provider
2404  ** in the "doc" structure; it may be empty.
2405  **
2406  ** If workspace creation is successful, the state of the resource
2407  ** object is updated appropriately.
2408  **
2409  ** This hook is optional; if the provider does not support workspaces,
2410  ** it should be set to NULL.
2411  */
2412  dav_error * (*make_workspace)(dav_resource *resource,
2413  apr_xml_doc *doc);
2414 
2415  /*
2416  ** Determine whether a null resource can be created as an activity.
2417  ** The provider may restrict activities to certain locations.
2418  ** Returns 0 if the resource cannot be an activity.
2419  **
2420  ** This hook is optional; if the provider does not support activities,
2421  ** it should be set to NULL.
2422  */
2424 
2425  /*
2426  ** Create an activity resource. The resource must not already
2427  ** exist.
2428  **
2429  ** If activity creation is successful, the state of the resource
2430  ** object is updated appropriately.
2431  **
2432  ** This hook is optional; if the provider does not support activities,
2433  ** it should be set to NULL.
2434  */
2435  dav_error * (*make_activity)(dav_resource *resource);
2436 
2437  /*
2438  ** Merge a resource (tree) into target resource (tree).
2439  **
2440  ** ### more doc...
2441  **
2442  ** This hook is optional; if the provider does not support merging,
2443  ** then this should be set to NULL.
2444  **
2445  ** API ISSUE: don't use the passed-in 'output' filter.
2446  **
2447  ** Instead, generate the response into the output filter stack for the
2448  ** request (r->output_filters). An implementation can use the request_rec
2449  ** that was passed to get_resource() for this purpose. Using 'output'
2450  ** filter for the response can cause unbounded memory usage.
2451  **
2452  ** See https://mail-archives.apache.org/mod_mbox/httpd-dev/201608.mbox/%3C20160822151917.GA22369%40redhat.com%3E
2453  */
2454  dav_error * (*merge)(dav_resource *target, dav_resource *source,
2455  int no_auto_merge, int no_checkout,
2456  apr_xml_elem *prop_elem,
2457  ap_filter_t *output);
2458 
2459  /*
2460  ** If a provider needs a context to associate with this hooks structure,
2461  ** then this field may be used. In most cases, it will just be NULL.
2462  */
2463  void *ctx;
2464 };
2465 
2466 
2467 /* --------------------------------------------------------------------
2468 **
2469 ** BINDING FUNCTIONS
2470 */
2471 
2472 /* binding provider hooks */
2474 
2475  /* Determine whether a resource can be the target of a binding.
2476  * Returns 0 if the resource cannot be a binding target.
2477  */
2479 
2480  /* Create a binding to a resource.
2481  * The resource argument is the target of the binding;
2482  * the binding argument must be a resource which does not already
2483  * exist.
2484  */
2485  dav_error * (*bind_resource)(const dav_resource *resource,
2486  dav_resource *binding);
2487 
2488  /*
2489  ** If a provider needs a context to associate with this hooks structure,
2490  ** then this field may be used. In most cases, it will just be NULL.
2491  */
2492  void *ctx;
2493 
2494 };
2495 
2496 
2497 /* --------------------------------------------------------------------
2498 **
2499 ** SEARCH(DASL) FUNCTIONS
2500 */
2501 
2502 /* search provider hooks */
2504  /* Set header for a OPTION method
2505  * An error may be returned.
2506  * To set a hadder, this function might call
2507  * apr_table_setn(r->headers_out, "DASL", dasl_optin1);
2508  *
2509  * Examples:
2510  * DASL: <DAV:basicsearch>
2511  * DASL: <http://foo.bar.com/syntax1>
2512  * DASL: <http://akuma.com/syntax2>
2513  */
2514  dav_error * (*set_option_head)(request_rec *r);
2515 
2516  /* Search resources
2517  * An error may be returned. *response will contain multistatus
2518  * responses (if any) suitable for the body of the error. It is also
2519  * possible to return NULL, yet still have multistatus responses.
2520  * In this case, typically the caller should return a 207 (Multistatus)
2521  * and the responses (in the body) as the HTTP response.
2522  */
2523  dav_error * (*search_resource)(request_rec *r,
2524  dav_response **response);
2525 
2526  /*
2527  ** If a provider needs a context to associate with this hooks structure,
2528  ** then this field may be used. In most cases, it will just be NULL.
2529  */
2530  void *ctx;
2531 
2532 };
2533 
2534 
2535 /* --------------------------------------------------------------------
2536 **
2537 ** MISCELLANEOUS STUFF
2538 */
2539 
2540 typedef struct {
2541  int propid; /* live property ID */
2542  const dav_hooks_liveprop *provider; /* the provider defining this prop */
2544 
2545 
2546 /* --------------------------------------------------------------------
2547 **
2548 ** DAV ACL HOOKS
2549 */
2550 
2552 {
2553  dav_error * (*acl_check_method)(request_rec *r,
2554  const dav_resource *resource);
2555 
2556  dav_error * (*acl_check_read)(request_rec *r,
2557  const dav_resource *resource);
2558 
2559  dav_error * (*acl_check_prop)(request_rec *r,
2560  const dav_resource *resource,
2561  const dav_prop_name *name,
2563 
2565  const dav_resource *resource,
2566  int new_resource_created);
2567  void *ctx;
2568 };
2569 
2570 DAV_DECLARE(void) dav_acl_provider_register(apr_pool_t *p,
2572 
2573 DAV_DECLARE(const dav_acl_provider *) dav_get_acl_providers(void);
2574 
2575 
2576 /* --------------------------------------------------------------------
2577 **
2578 ** DAV OPTIONS
2579 */
2580 #define DAV_OPTIONS_EXTENSION_GROUP "dav_options"
2581 
2582 typedef struct dav_options_provider
2583 {
2584  dav_error* (*dav_header)(request_rec *r,
2585  const dav_resource *resource,
2587 
2588  dav_error* (*dav_method)(request_rec *r,
2589  const dav_resource *resource,
2591 
2592  void *ctx;
2594 
2595 extern DAV_DECLARE(const dav_options_provider *) dav_get_options_providers(const char *name);
2596 
2597 extern DAV_DECLARE(void) dav_options_provider_register(apr_pool_t *p,
2598  const char *name,
2600 
2601 /* --------------------------------------------------------------------
2602 **
2603 ** DAV RESOURCE TYPE HOOKS
2604 */
2605 
2607 {
2608  int (*get_resource_type)(const dav_resource *resource,
2609  const char **name,
2610  const char **uri);
2612 
2613 #define DAV_RESOURCE_TYPE_GROUP "dav_resource_type"
2614 
2615 DAV_DECLARE(void) dav_resource_type_provider_register(apr_pool_t *p,
2616  const char *name,
2618 
2619 DAV_DECLARE(const dav_resource_type_provider *) dav_get_resource_type_providers(const char *name);
2620 
2621 #ifdef __cplusplus
2622 }
2623 #endif
2624 
2625 #endif /* _MOD_DAV_H_ */
2626 
const dav_hooks_propdb * propdb
Definition: mod_dav.h:664
size_t apr_size_t
Definition: apr.h:397
struct dav_if_state_list * state
Definition: mod_dav.h:791
dav_response * response
Definition: mod_dav.h:1715
dav_buffer work_buf
Definition: mod_dav.h:1774
void(* close)(dav_db *db)
Definition: mod_dav.h:1116
Definition: mod_dav.h:1062
apr_text * propstats
Definition: mod_dav.h:490
#define DAV_DECLARE_NONSTD(type)
Definition: mod_dav.h:86
Definition: mod_dav.h:1053
Definition: mod_dav.h:508
struct dav_if_header * next
Definition: mod_dav.h:792
void * ctx
Definition: mod_dav.h:923
dav_buffer * pbuf
Definition: mod_dav.h:457
struct dav_lockdb_private dav_lockdb_private
Definition: mod_dav.h:1228
const dav_hooks_repository * repos
Definition: mod_dav.h:663
Definition: mod_dav.h:1039
Definition: apr_xml.h:200
Definition: mod_dav.h:662
const char *const * namespace_uris
Definition: mod_dav.h:862
Definition: mod_dav.h:1041
struct dav_prop_ctx dav_prop_ctx
Definition: apr_tables.h:62
void * liveprop_ctx
Definition: mod_dav.h:1674
const dav_resource dav_lockdb const apr_xml_doc dav_lock ** lock_request
Definition: mod_dav.h:1324
int versioned
Definition: mod_dav.h:398
Definition: mod_dav.h:769
void * ctx
Definition: mod_dav.h:2463
APR-UTIL DBM library.
Definition: mod_dav.h:1072
const char const char apr_text_header * body
Definition: mod_dav.h:1621
void(* get_vsn_options)(apr_pool_t *p, apr_text_header *phdr)
Definition: mod_dav.h:2181
Definition: mod_dav.h:1803
const dav_acl_provider * acls
Definition: mod_dav.h:423
const dav_resource * resrouce
Definition: mod_dav.h:1324
Definition: mod_dav.h:305
Definition: mod_dav.h:2503
dav_resource int undo
Definition: mod_dav.h:2149
Definition: mod_dav.h:1045
apr_pool_t * scratchpool
Definition: mod_dav.h:1754
Definition: mod_dav.h:1698
apr_array_header_t * prop_ctx
Definition: mod_dav.h:575
Definition: mod_dav.h:1049
The representation of a filter chain.
Definition: util_filter.h:278
Definition: mod_dav.h:1375
const dav_resource * root
Definition: mod_dav.h:1734
const char * uri
Definition: mod_dav.h:789
Definition: mod_dav.h:299
Definition: mod_dav.h:601
int operation
Definition: mod_dav.h:1667
dav_lock_type
Definition: mod_dav.h:1254
int(* can_be_workspace)(const dav_resource *resource)
Definition: mod_dav.h:2399
apr_bucket_brigade request_rec apr_pool_t * pool
Definition: mod_dav.h:552
Definition: mod_dav.h:1061
Definition: mod_dav.h:1295
int propid
Definition: mod_dav.h:2541
void * ctx
Definition: mod_dav.h:2530
void * ctx
Definition: mod_dav.h:670
Definition: mod_dav.h:1038
const dav_resource dav_lockdb dav_lock * request
Definition: mod_dav.h:1332
int propfind_type
Definition: mod_dav.h:1760
dav_auto_version
Definition: mod_dav.h:2090
Definition: mod_dav.h:1661
Definition: mod_dav.h:1048
void * ctx
Definition: mod_dav.h:2044
Definition: mod_dav.h:1058
Definition: apr_xml.h:162
Definition: mod_dav.h:2551
Apache XML library.
struct dav_error * prev
Definition: mod_dav.h:131
const char * desc
Definition: mod_dav.h:124
Definition: mod_dav.h:532
Definition: mod_dav.h:1071
Definition: mod_dav.h:1028
apr_text * xmlns
Definition: mod_dav.h:491
dav_resource_type
Definition: mod_dav.h:296
int parent_checkedout
Definition: mod_dav.h:2104
APR Hash Tables.
struct dav_rollback_item * rollback
Definition: mod_dav.h:1675
int dummy_header
Definition: mod_dav.h:794
Definition: mod_dav.h:1030
Definition: mod_dav.h:1067
Definition: mod_dav.h:309
Definition: mod_dav.h:1033
struct dav_resource_type_provider dav_resource_type_provider
Definition: mod_dav.h:2606
Definition: mod_dav.h:528
apr_pool_t * pool
Definition: mod_dav.h:421
Definition: mod_dav.h:389
Definition: mod_dav.h:1050
Definition: mod_dav.h:303
Definition: mod_dav.h:1703
Definition: mod_dav.h:2473
int(* exists)(dav_db *db, const dav_prop_name *name)
Definition: mod_dav.h:1183
apr_hash_t * prefix_uri
Definition: mod_dav.h:604
dav_locktoken_list ** ltl
Definition: mod_dav.h:804
Definition: mod_dav.h:1037
Definition: mod_dav.h:1112
const char * name
Definition: mod_dav.h:938
const dav_hooks_search * search
Definition: mod_dav.h:668
const dav_resource const dav_locktoken * locktoken
Definition: mod_dav.h:1329
void * ctx
Definition: mod_dav.h:425
Definition: apr_xml.h:53
int count
Definition: mod_dav.h:605
apr_pool_t int strip_white
Definition: mod_dav.h:587
apr_pool_t * pool
Definition: mod_dav.h:1731
const char const char * uri
Definition: mod_dav.h:614
int baselined
Definition: mod_dav.h:402
dav_lock * locks
Definition: mod_dav.h:1319
Definition: mod_dav.h:1026
void * ctx
Definition: mod_dav.h:2592
Definition: apr_buckets.h:258
int skip_root
Definition: mod_dav.h:1770
const char * nmspace
Definition: mod_dav.h:2161
dav_if_state_type
Definition: mod_dav.h:766
const char * name
Definition: mod_dav.h:1108
const char * prefix
Definition: mod_dav.h:614
Definition: mod_dav.h:1065
Definition: mod_dav.h:525
Definition: mod_dav.h:2093
apr_xml_doc * doc
Definition: mod_dav.h:1759
int is_liveprop
Definition: mod_dav.h:1673
struct dav_if_state_list * next
Definition: mod_dav.h:784
Definition: mod_dav.h:1802
Definition: mod_dav.h:770
dav_lockdb const dav_resource int apr_array_header_t dav_propdb ** propdb
Definition: mod_dav.h:1593
dav_lockdb const dav_resource int int depth
Definition: mod_dav.h:1336
Definition: mod_dav.h:1044
Definition: mod_dav.h:1813
request_rec * r
Definition: mod_dav.h:1756
int dav_get_props_result * propstats
Definition: mod_dav.h:1779
Definition: mod_dav.h:1055
dav_buffer apr_size_t size
Definition: mod_dav.h:457
request_rec int apr_array_header_t * namespaces
Definition: mod_dav.h:562
Definition: mod_dav.h:1051
Definition: mod_dav.h:1023
Definition: mod_dav.h:815
int int apr_status_t const char * desc
Definition: mod_dav.h:141
void * ctx
Definition: mod_dav.h:2567
void * ctx
Definition: mod_dav.h:1573
const char * name
Definition: mod_dav.h:2162
Definition: mod_dav.h:1063
Definition: mod_dav.h:1239
Definition: mod_dav.h:1255
Definition: mod_dav.h:2101
apr_bucket_brigade * bb
Definition: mod_dav.h:552
dav_lock_rectype
Definition: mod_dav.h:1259
const dav_lock * lock
Definition: mod_dav.h:1769
struct dav_walker_ctx dav_walker_ctx
Definition: mod_dav.h:936
HTTP Daemon routines.
apr_size_t alloc_len
Definition: mod_dav.h:449
const dav_resource dav_lockdb * lockdb
Definition: mod_dav.h:1324
Apache hook functions.
request_rec * r
Definition: mod_dav.h:1680
Definition: mod_dav.h:1046
dav_lockdb const dav_resource int apr_array_header_t * ns_xlate
Definition: mod_dav.h:1593
apr_text * propstat_404
Definition: mod_dav.h:1765
int int apr_status_t aprerr
Definition: mod_dav.h:141
int(* is_same_resource)(const dav_resource *res1, const dav_resource *res2)
Definition: mod_dav.h:1870
Definition: mod_dav.h:1260
int int error_id
Definition: mod_dav.h:141
const char * etag
Definition: mod_dav.h:781
Definition: mod_dav.h:2092
int
Definition: mod_proxy.h:643
dav_lock_rectype rectype
Definition: mod_dav.h:1297
Definition: mod_dav.h:2540
struct dav_options_provider dav_options_provider
Definition: mod_dav.h:488
Definition: mod_dav.h:1075
Definition: mod_dav.h:1700
Definition: mod_dav.h:1024
Definition: mod_dav.h:1742
const dav_acl_provider * acl
Definition: mod_dav.h:2571
#define APR_DECLARE_EXTERNAL_HOOK(ns, link, ret, name, args)
Definition: apr_hooks.h:118
struct dav_db dav_db
Definition: mod_dav.h:1102
int(* versionable)(const dav_resource *resource)
Definition: mod_dav.h:2195
const char * childtags
Definition: mod_dav.h:133
dav_buffer const void apr_size_t amt
Definition: mod_dav.h:477
apr_xml_elem * prop
Definition: mod_dav.h:1665
dav_error * src
Definition: mod_dav.h:186
dav_error * err
Definition: mod_dav.h:203
const char const dav_liveprop_group * group
Definition: mod_dav.h:960
dav_lockdb const dav_resource int ro
Definition: mod_dav.h:1593
int error_id
Definition: mod_dav.h:123
int(* is_bindable)(const dav_resource *resource)
Definition: mod_dav.h:2478
APR Table library.
apr_bucket_brigade * bb
Definition: mod_dav.h:1751
struct dav_stream dav_stream
Definition: mod_dav.h:1799
time_t timeout
Definition: mod_dav.h:1305
void * walk_ctx
Definition: mod_dav.h:1706
Definition: mod_dav.h:1064
const char const char * propname
Definition: mod_dav.h:1621
const dav_resource * resource
Definition: mod_dav.h:1712
dav_if_state_type type
Definition: mod_dav.h:775
dav_lockdb const dav_resource int resource_state
Definition: mod_dav.h:1336
Definition: mod_dav.h:1106
int flags
Definition: mod_dav.h:1772
apr_size_t uri_len
Definition: mod_dav.h:790
Definition: mod_dav.h:1056
const dav_locktoken * locktoken
Definition: mod_dav.h:1768
Definition: mod_dav.h:2091
int dav_response * first
Definition: mod_dav.h:570
Definition: mod_dav.h:1025
dav_lockdb_private * info
Definition: mod_dav.h:1244
Definition: mod_dav.h:1059
Definition: mod_dav.h:773
const dav_hooks_liveprop * provider
Definition: mod_dav.h:2542
dav_locktoken * locktoken
Definition: mod_dav.h:782
dav_propdb * propdb
Definition: mod_dav.h:1663
int status
Definition: mod_dav.h:122
Definition: mod_dav.h:1256
struct dav_if_header dav_if_header
char * buf
Definition: mod_dav.h:451
namespace const char * tagname
Definition: mod_dav.h:153
Definition: mod_dav.h:1052
dav_resource_type type
Definition: mod_dav.h:390
#define DAV_DECLARE(type)
Definition: mod_dav.h:85
int is_locknull
Definition: mod_dav.h:1298
dav_auto_version(* auto_versionable)(const dav_resource *resource)
Definition: mod_dav.h:2206
struct dav_liveprop_rollback dav_liveprop_rollback
Definition: mod_dav.h:813
const char * desc
Definition: mod_dav.h:498
struct apr_hash_t apr_hash_t
Definition: apr_hash.h:52
dav_error dav_response * response
Definition: mod_dav.h:203
const dav_liveprop_group const dav_liveprop_spec ** info
Definition: mod_dav.h:966
Definition: mod_dav.h:311
Definition: mod_dav.h:1036
Definition: mod_dav.h:1250
dav_buffer apr_size_t extra_needed
Definition: mod_dav.h:465
Definition: mod_dav.h:787
Definition: mod_dav.h:1060
request_rec int must_be_absolute
Definition: mod_dav.h:515
apr_pool_t * p
struct dav_if_state_list dav_if_state_list
int resource_versioned
Definition: mod_dav.h:2102
const dav_locktoken * locktoken
Definition: mod_dav.h:1307
Definition: mod_dav.h:1057
dav_hooks_propdb dav_hooks_db
Definition: mod_dav.h:276
int ro
Definition: mod_dav.h:1242
Definition: mod_dav.h:1699
const char * uri
Definition: mod_dav.h:410
int working
Definition: mod_dav.h:406
dav_stream_mode
Definition: mod_dav.h:1801
dav_lock_scope
Definition: mod_dav.h:1248
struct dav_lock_private dav_lock_private
Definition: mod_dav.h:1233
int is_writable
Definition: mod_dav.h:942
const char const dav_provider * hooks
Definition: mod_dav.h:726
const char const dav_options_provider * provider
Definition: mod_dav.h:2598
Definition: mod_dav.h:297
struct dav_lock * next
Definition: mod_dav.h:1314
dav_resource int dav_auto_version_info * av_info
Definition: mod_dav.h:2128
dav_lock_type type
Definition: mod_dav.h:1303
struct dav_propdb dav_propdb
Definition: mod_dav.h:1588
dav_resource_private * info
Definition: mod_dav.h:414
struct dav_namespace_map dav_namespace_map
Definition: mod_dav.h:1103
Definition: mod_dav.h:1027
void(* acl_post_processing)(request_rec *r, const dav_resource *resource, int new_resource_created)
Definition: mod_dav.h:2564
int ns
Definition: mod_dav.h:937
apr_hash_t * uri_prefix
Definition: mod_dav.h:603
Definition: mod_dav.h:1073
struct dav_error dav_error
struct dav_resource_private dav_resource_private
Definition: mod_dav.h:320
Definition: mod_dav.h:1066
struct dav_deadprop_rollback dav_deadprop_rollback
Definition: mod_dav.h:1104
Definition: mod_dav.h:1262
const dav_liveprop_spec * specs
Definition: mod_dav.h:953
A structure that represents the current request.
Definition: httpd.h:819
Definition: mod_dav.h:1054
Definition: mod_dav.h:1719
const dav_resource dav_lockdb const apr_xml_doc * doc
Definition: mod_dav.h:1324
Definition: mod_dav.h:121
Apache filter library.
int status
Definition: mod_dav.h:503
const char * ns
Definition: mod_dav.h:1107
dav_buffer const void apr_size_t apr_size_t pad
Definition: mod_dav.h:477
int condition
Definition: mod_dav.h:777
apr_status_t aprerr
Definition: mod_dav.h:126
apr_pool_t * pool
Definition: mod_dav.h:602
const dav_hooks_binding * binding
Definition: mod_dav.h:667
const dav_if_header * if_header
Definition: mod_dav.h:1767
Definition: mod_dav.h:1020
int(* can_be_activity)(const dav_resource *resource)
Definition: mod_dav.h:2423
void * ctx
Definition: mod_dav.h:1211
struct dav_resource dav_resource
apr_size_t cur_len
Definition: mod_dav.h:450
struct dav_locktoken dav_locktoken
Definition: mod_dav.h:434
const char *const * namespace_uris
Definition: mod_dav.h:954
int depth
Definition: mod_dav.h:1304
dav_buffer const char * str
Definition: mod_dav.h:461
dav_error err
Definition: mod_dav.h:511
const dav_resource * resource
Definition: mod_dav.h:994
int status
Definition: mod_dav.h:141
const dav_resource dav_prop_insert what
Definition: mod_dav.h:994
int int const char dav_error * prev
Definition: mod_dav.h:170
Definition: mod_dav.h:1070
dav_buffer const void * mem
Definition: mod_dav.h:477
dav_resource * parent_resource
Definition: mod_dav.h:2105
const char * name
Definition: mod_dav.h:726
dav_lock_scope scope
Definition: mod_dav.h:1302
Definition: apr_xml.h:64
const dav_hooks_repository * hooks
Definition: mod_dav.h:416
dav_walk_params w
Definition: mod_dav.h:1745
const char * tagname
Definition: mod_dav.h:128
int handle_get
Definition: mod_dav.h:1821
int walk_type
Definition: mod_dav.h:1721
struct apr_pool_t apr_pool_t
Definition: apr_pools.h:60
Definition: mod_dav.h:1029
struct dav_locktoken_list * next
Definition: mod_dav.h:800
typedef void(APR_THREAD_FUNC *PFN_HSE_IO_COMPLETION)(EXTENSION_CONTROL_BLOCK *ecb
const dav_hooks_vsn * vsn
Definition: mod_dav.h:666
int apr_status_t
Definition: apr_errno.h:44
int collection
Definition: mod_dav.h:394
request_rec * out_req
Definition: mod_dav.h:2066
request_rec * r
Definition: mod_dav.h:515
dav_get_props_result propresult
Definition: mod_dav.h:501
Definition: mod_dav.h:952
dav_lockdb * lockdb
Definition: mod_dav.h:1737
request_rec * rnew
Definition: mod_dav.h:510
Definition: mod_dav.h:520
Definition: mod_dav.h:1031
void * walk_ctx
Definition: mod_dav.h:1728
void * ctx
Definition: mod_dav.h:2492
const dav_hooks_liveprop * hooks
Definition: mod_dav.h:955
dav_resource int parent_only
Definition: mod_dav.h:2128
Definition: mod_dav.h:313
struct dav_response * next
Definition: mod_dav.h:505
Definition: mod_dav.h:530
apr_text_header * phdr
Definition: mod_dav.h:632
int def_depth
Definition: mod_dav.h:579
Definition: mod_dav.h:1249
dav_prop_insert
Definition: mod_dav.h:519
Definition: mod_dav.h:1047
Definition: mod_dav.h:1032
struct dav_locktoken_list dav_locktoken_list
int propid
Definition: mod_dav.h:940
const dav_hooks_locks * locks
Definition: mod_dav.h:665
int exists
Definition: mod_dav.h:392
apr_pool_t * pool
Definition: mod_dav.h:1709
Definition: mod_dav.h:1261
Definition: mod_dav.h:1251
int(* report_label_header_allowed)(const apr_xml_doc *doc)
Definition: mod_dav.h:2293
const dav_hooks_locks * hooks
Definition: mod_dav.h:1241
Definition: mod_dav.h:2582
dav_error * err
Definition: mod_dav.h:1677
Definition: mod_dav.h:768
const char * auth_user
Definition: mod_dav.h:1310
const char * href
Definition: mod_dav.h:497
dav_resource int dav_locktoken dav_response int flags
Definition: mod_dav.h:1346
Definition: mod_dav.h:495
int resource_checkedout
Definition: mod_dav.h:2103
int(* is_parent_resource)(const dav_resource *res1, const dav_resource *res2)
Definition: mod_dav.h:1880
dav_lock_private * info
Definition: mod_dav.h:1312
struct dav_lock dav_lock
Definition: mod_dav.h:307
Definition: mod_dav.h:797
dav_resource int int unlock
Definition: mod_dav.h:2149
off_t apr_off_t
Definition: apr.h:399
Definition: mod_dav.h:1040
dav_locktoken * locktoken
Definition: mod_dav.h:799
const char * ns_uri
Definition: mod_dav.h:989
Definition: mod_dav.h:2167
Definition: mod_dav.h:447
const char * owner
Definition: mod_dav.h:1309
Definition: mod_dav.h:2160