www/httpd-win32.patch.txt

   1 Index: CHANGES
   2 ===================================================================
   3 --- CHANGES     (revision 155344)
   4 +++ CHANGES     (revision 155345)
   5 @@ -2,6 +2,9 @@
   6
   7    [Remove entries to the current 2.0 section below, when backported]
   8
   9 +  *) Correctly export all mod_dav public functions.
  10 +     [Branko Èibej <brane xbc.nu>]
  11 +
  12  Changes with Apache 2.1.3
  13
  14    *) core_input_filter: Move buckets to a persistent brigade instead of
  15 Index: modules/dav/main/mod_dav.h
  16 ===================================================================
  17 --- modules/dav/main/mod_dav.h  (revision 155344)
  18 +++ modules/dav/main/mod_dav.h  (revision 155345)
  19 @@ -464,8 +464,8 @@
  20  } dav_lookup_result;
  21
  22
  23 -dav_lookup_result dav_lookup_uri(const char *uri, request_rec *r,
  24 -                                 int must_be_absolute);
  25 +DAV_DECLARE(dav_lookup_result) dav_lookup_uri(const char *uri, request_rec *r,
  26 +                                              int must_be_absolute);
  27
  28  /* defines type of property info a provider is to return */
  29  typedef enum {
  30 @@ -492,10 +492,12 @@
  31  #define DAV_STYLE_RFC822        2
  32  #define DAV_TIMEBUF_SIZE        30
  33
  34 -int dav_get_depth(request_rec *r, int def_depth);
  35 +DAV_DECLARE(int) dav_get_depth(request_rec *r, int def_depth);
  36
  37 -int dav_validate_root(const apr_xml_doc *doc, const char *tagname);
  38 -apr_xml_elem *dav_find_child(const apr_xml_elem *elem, const char *tagname);
  39 +DAV_DECLARE(int) dav_validate_root(const apr_xml_doc *doc,
  40 +                                   const char *tagname);
  41 +DAV_DECLARE(apr_xml_elem *) dav_find_child(const apr_xml_elem *elem,
  42 +                                           const char *tagname);
  43
  44  /* gather up all the CDATA into a single string */
  45  DAV_DECLARE(const char *) dav_xml_get_cdata(const apr_xml_elem *elem, apr_pool_t *pool,
  46 @@ -631,15 +633,15 @@
  47                           (request_rec *r, const dav_resource *resource,
  48                            dav_prop_insert what, apr_text_header *phdr))
  49
  50 -const dav_hooks_locks *dav_get_lock_hooks(request_rec *r);
  51 -const dav_hooks_propdb *dav_get_propdb_hooks(request_rec *r);
  52 -const dav_hooks_vsn *dav_get_vsn_hooks(request_rec *r);
  53 -const dav_hooks_binding *dav_get_binding_hooks(request_rec *r);
  54 -const dav_hooks_search *dav_get_search_hooks(request_rec *r);
  55 +DAV_DECLARE(const dav_hooks_locks *) dav_get_lock_hooks(request_rec *r);
  56 +DAV_DECLARE(const dav_hooks_propdb *) dav_get_propdb_hooks(request_rec *r);
  57 +DAV_DECLARE(const dav_hooks_vsn *) dav_get_vsn_hooks(request_rec *r);
  58 +DAV_DECLARE(const dav_hooks_binding *) dav_get_binding_hooks(request_rec *r);
  59 +DAV_DECLARE(const dav_hooks_search *) dav_get_search_hooks(request_rec *r);
  60
  61  DAV_DECLARE(void) dav_register_provider(apr_pool_t *p, const char *name,
  62                                          const dav_provider *hooks);
  63 -const dav_provider * dav_lookup_provider(const char *name);
  64 +DAV_DECLARE(const dav_provider *) dav_lookup_provider(const char *name);
  65
  66
  67  /* ### deprecated */
  68 @@ -712,7 +714,8 @@
  69      struct dav_locktoken_list *next;
  70  } dav_locktoken_list;
  71
  72 -dav_error * dav_get_locktoken_list(request_rec *r, dav_locktoken_list **ltl);
  73 +DAV_DECLARE(dav_error *) dav_get_locktoken_list(request_rec *r,
  74 +                                                dav_locktoken_list **ltl);
  75
  76
  77  /* --------------------------------------------------------------------
  78 @@ -885,22 +888,27 @@
  79  DAV_DECLARE(int) dav_get_liveprop_ns_index(const char *uri);
  80
  81  /* ### docco */
  82 -int dav_get_liveprop_ns_count(void);
  83 +DAV_DECLARE(int) dav_get_liveprop_ns_count(void);
  84
  85  /* ### docco */
  86 -void dav_add_all_liveprop_xmlns(apr_pool_t *p, apr_text_header *phdr);
  87 +DAV_DECLARE(void) dav_add_all_liveprop_xmlns(apr_pool_t *p,
  88 +                                             apr_text_header *phdr);
  89
  90  /*
  91  ** The following three functions are part of mod_dav's internal handling
  92  ** for the core WebDAV properties. They are not part of mod_dav's API.
  93  */
  94 -int dav_core_find_liveprop(const dav_resource *resource,
  95 -                           const char *ns_uri, const char *name,
  96 -                           const dav_hooks_liveprop **hooks);
  97 -void dav_core_insert_all_liveprops(request_rec *r,
  98 -                                   const dav_resource *resource,
  99 -                                   dav_prop_insert what, apr_text_header *phdr);
 100 -void dav_core_register_uris(apr_pool_t *p);
 101 +DAV_DECLARE_NONSTD(int) dav_core_find_liveprop(
 102 +    const dav_resource *resource,
 103 +    const char *ns_uri,
 104 +    const char *name,
 105 +    const dav_hooks_liveprop **hooks);
 106 +DAV_DECLARE_NONSTD(void) dav_core_insert_all_liveprops(
 107 +    request_rec *r,
 108 +    const dav_resource *resource,
 109 +    dav_prop_insert what,
 110 +    apr_text_header *phdr);
 111 +DAV_DECLARE_NONSTD(void) dav_core_register_uris(apr_pool_t *p);
 112
 113
 114  /*
 115 @@ -1126,7 +1134,7 @@
 116  /* Used to represent a Timeout header of "Infinity" */
 117  #define DAV_TIMEOUT_INFINITE 0
 118
 119 -time_t dav_get_timeout(request_rec *r);
 120 +DAV_DECLARE(time_t) dav_get_timeout(request_rec *r);
 121
 122  /*
 123  ** Opaque, provider-specific information for a lock database.
 124 @@ -1221,34 +1229,40 @@
 125  } dav_lock;
 126
 127  /* Property-related public lock functions */
 128 -const char *dav_lock_get_activelock(request_rec *r, dav_lock *locks,
 129 -                                    dav_buffer *pbuf);
 130 +DAV_DECLARE(const char *)dav_lock_get_activelock(request_rec *r,
 131 +                                                 dav_lock *locks,
 132 +                                                 dav_buffer *pbuf);
 133
 134  /* LockDB-related public lock functions */
 135 -dav_error * dav_lock_parse_lockinfo(request_rec *r,
 136 -                                    const dav_resource *resrouce,
 137 -                                    dav_lockdb *lockdb,
 138 -                                    const apr_xml_doc *doc,
 139 -                                    dav_lock **lock_request);
 140 -int dav_unlock(request_rec *r, const dav_resource *resource,
 141 -               const dav_locktoken *locktoken);
 142 -dav_error * dav_add_lock(request_rec *r, const dav_resource *resource,
 143 -                         dav_lockdb *lockdb, dav_lock *request,
 144 -                         dav_response **response);
 145 -dav_error * dav_notify_created(request_rec *r,
 146 -                               dav_lockdb *lockdb,
 147 -                               const dav_resource *resource,
 148 -                               int resource_state,
 149 -                               int depth);
 150 +DAV_DECLARE(dav_error *) dav_lock_parse_lockinfo(request_rec *r,
 151 +                                                 const dav_resource *resrouce,
 152 +                                                 dav_lockdb *lockdb,
 153 +                                                 const apr_xml_doc *doc,
 154 +                                                 dav_lock **lock_request);
 155 +DAV_DECLARE(int) dav_unlock(request_rec *r,
 156 +                            const dav_resource *resource,
 157 +                            const dav_locktoken *locktoken);
 158 +DAV_DECLARE(dav_error *) dav_add_lock(request_rec *r,
 159 +                                      const dav_resource *resource,
 160 +                                      dav_lockdb *lockdb, dav_lock *request,
 161 +                                      dav_response **response);
 162 +DAV_DECLARE(dav_error *) dav_notify_created(request_rec *r,
 163 +                                            dav_lockdb *lockdb,
 164 +                                            const dav_resource *resource,
 165 +                                            int resource_state,
 166 +                                            int depth);
 167
 168  DAV_DECLARE(dav_error*) dav_lock_query(dav_lockdb *lockdb,
 169                                         const dav_resource *resource,
 170                                         dav_lock **locks);
 171
 172 -dav_error * dav_validate_request(request_rec *r, dav_resource *resource,
 173 -                                 int depth, dav_locktoken *locktoken,
 174 -                                 dav_response **response, int flags,
 175 -                                 dav_lockdb *lockdb);
 176 +DAV_DECLARE(dav_error *) dav_validate_request(request_rec *r,
 177 +                                              dav_resource *resource,
 178 +                                              int depth,
 179 +                                              dav_locktoken *locktoken,
 180 +                                              dav_response **response,
 181 +                                              int flags,
 182 +                                              dav_lockdb *lockdb);
 183  /*
 184  ** flags:
 185  **    0x0F -- reserved for <dav_lock_scope> values
 186 @@ -1263,7 +1277,8 @@
 187  #define DAV_VALIDATE_IS_PARENT  0x0100  /* for internal use */
 188
 189  /* Lock-null related public lock functions */
 190 -int dav_get_resource_state(request_rec *r, const dav_resource *resource);
 191 +DAV_DECLARE(int) dav_get_resource_state(request_rec *r,
 192 +                                        const dav_resource *resource);
 193
 194  /* Lock provider hooks. Locking is optional, so there may be no
 195   * lock provider for a given repository.
 196 @@ -1484,7 +1499,7 @@
 197  typedef struct dav_propdb dav_propdb;
 198
 199
 200 -dav_error *dav_open_propdb(
 201 +DAV_DECLARE(dav_error *) dav_open_propdb(
 202      request_rec *r,
 203      dav_lockdb *lockdb,
 204      const dav_resource *resource,
 205 @@ -1492,17 +1507,17 @@
 206      apr_array_header_t *ns_xlate,
 207      dav_propdb **propdb);
 208
 209 -void dav_close_propdb(dav_propdb *db);
 210 +DAV_DECLARE(void) dav_close_propdb(dav_propdb *db);
 211
 212 -dav_get_props_result dav_get_props(
 213 +DAV_DECLARE(dav_get_props_result) dav_get_props(
 214      dav_propdb *db,
 215      apr_xml_doc *doc);
 216
 217 -dav_get_props_result dav_get_allprops(
 218 +DAV_DECLARE(dav_get_props_result) dav_get_allprops(
 219      dav_propdb *db,
 220      dav_prop_insert what);
 221
 222 -void dav_get_liveprop_supported(
 223 +DAV_DECLARE(void) dav_get_liveprop_supported(
 224      dav_propdb *propdb,
 225      const char *ns_uri,
 226      const char *propname,
 227 @@ -1567,10 +1582,10 @@
 228
 229  } dav_prop_ctx;
 230
 231 -void dav_prop_validate(dav_prop_ctx *ctx);
 232 -void dav_prop_exec(dav_prop_ctx *ctx);
 233 -void dav_prop_commit(dav_prop_ctx *ctx);
 234 -void dav_prop_rollback(dav_prop_ctx *ctx);
 235 +DAV_DECLARE_NONSTD(void) dav_prop_validate(dav_prop_ctx *ctx);
 236 +DAV_DECLARE_NONSTD(void) dav_prop_exec(dav_prop_ctx *ctx);
 237 +DAV_DECLARE_NONSTD(void) dav_prop_commit(dav_prop_ctx *ctx);
 238 +DAV_DECLARE_NONSTD(void) dav_prop_rollback(dav_prop_ctx *ctx);
 239
 240  #define DAV_PROP_CTX_HAS_ERR(dpc)  ((dpc).err && (dpc).err->status >= 300)
 241
 242 @@ -1933,9 +1948,9 @@
 243   * If there were any headers in the request which require a Vary header
 244   * in the response, add it.
 245   */
 246 -void dav_add_vary_header(request_rec *in_req,
 247 -                         request_rec *out_req,
 248 -                         const dav_resource *resource);
 249 +DAV_DECLARE(void) dav_add_vary_header(request_rec *in_req,
 250 +                                      request_rec *out_req,
 251 +                                      const dav_resource *resource);
 252
 253  /*
 254  ** Flags specifying auto-versioning behavior, returned by
 255 @@ -1994,7 +2009,7 @@
 256   * to restore both parent and child resources to the state they were in
 257   * before the auto-versioning operations occurred.
 258   */
 259 -dav_error *dav_auto_checkout(
 260 +DAV_DECLARE(dav_error *) dav_auto_checkout(
 261      request_rec *r,
 262      dav_resource *resource,
 263      int parent_only,
 264 @@ -2015,7 +2030,7 @@
 265   * was checked out (i.e. the parent_only was != 0 in the
 266   * dav_auto_checkout call).
 267   */
 268 -dav_error *dav_auto_checkin(
 269 +DAV_DECLARE(dav_error *) dav_auto_checkin(
 270      request_rec *r,
 271      dav_resource *resource,
 272      int undo,
 273 @@ -2391,7 +2406,7 @@
 274  */
 275
 276  /* fetch the "LimitXMLRequestBody" in force for this resource */
 277 -apr_size_t dav_get_limit_xml_body(const request_rec *r);
 278 +DAV_DECLARE(apr_size_t) dav_get_limit_xml_body(const request_rec *r);
 279
 280  typedef struct {
 281      int propid;                          /* live property ID */
 282 Index: modules/dav/main/liveprop.c
 283 ===================================================================
 284 --- modules/dav/main/liveprop.c (revision 155344)
 285 +++ modules/dav/main/liveprop.c (revision 155345)
 286 @@ -58,12 +58,13 @@
 287      return (int)apr_hash_get(dav_liveprop_uris, uri, APR_HASH_KEY_STRING);
 288  }
 289
 290 -int dav_get_liveprop_ns_count(void)
 291 +DAV_DECLARE(int) dav_get_liveprop_ns_count(void)
 292  {
 293      return dav_liveprop_count;
 294  }
 295
 296 -void dav_add_all_liveprop_xmlns(apr_pool_t *p, apr_text_header *phdr)
 297 +DAV_DECLARE(void) dav_add_all_liveprop_xmlns(apr_pool_t *p,
 298 +                                             apr_text_header *phdr)
 299  {
 300      apr_hash_index_t *idx = apr_hash_first(p, dav_liveprop_uris);
 301
 302 Index: modules/dav/main/props.c
 303 ===================================================================
 304 --- modules/dav/main/props.c    (revision 155344)
 305 +++ modules/dav/main/props.c    (revision 155345)
 306 @@ -514,11 +514,11 @@
 307      return NULL;
 308  }
 309
 310 -dav_error *dav_open_propdb(request_rec *r, dav_lockdb *lockdb,
 311 -                           const dav_resource *resource,
 312 -                           int ro,
 313 -                           apr_array_header_t * ns_xlate,
 314 -                           dav_propdb **p_propdb)
 315 +DAV_DECLARE(dav_error *)dav_open_propdb(request_rec *r, dav_lockdb *lockdb,
 316 +                                        const dav_resource *resource,
 317 +                                        int ro,
 318 +                                        apr_array_header_t * ns_xlate,
 319 +                                        dav_propdb **p_propdb)
 320  {
 321      dav_propdb *propdb = apr_pcalloc(r->pool, sizeof(*propdb));
 322
 323 @@ -552,7 +552,7 @@
 324      return NULL;
 325  }
 326
 327 -void dav_close_propdb(dav_propdb *propdb)
 328 +DAV_DECLARE(void) dav_close_propdb(dav_propdb *propdb)
 329  {
 330      if (propdb->db != NULL) {
 331          (*propdb->db_hooks->close)(propdb->db);
 332 @@ -565,7 +565,8 @@
 333      return;
 334  }
 335
 336 -dav_get_props_result dav_get_allprops(dav_propdb *propdb, dav_prop_insert what)
 337 +DAV_DECLARE(dav_get_props_result) dav_get_allprops(dav_propdb *propdb,
 338 +                                                   dav_prop_insert what)
 339  {
 340      const dav_hooks_db *db_hooks = propdb->db_hooks;
 341      apr_text_header hdr = { 0 };
 342 @@ -692,7 +693,8 @@
 343      return result;
 344  }
 345
 346 -dav_get_props_result dav_get_props(dav_propdb *propdb, apr_xml_doc *doc)
 347 +DAV_DECLARE(dav_get_props_result) dav_get_props(dav_propdb *propdb,
 348 +                                                apr_xml_doc *doc)
 349  {
 350      const dav_hooks_db *db_hooks = propdb->db_hooks;
 351      apr_xml_elem *elem = dav_find_child(doc->root, "prop");
 352 @@ -879,10 +881,10 @@
 353      return result;
 354  }
 355
 356 -void dav_get_liveprop_supported(dav_propdb *propdb,
 357 -                                const char *ns_uri,
 358 -                                const char *propname,
 359 -                                apr_text_header *body)
 360 +DAV_DECLARE(void) dav_get_liveprop_supported(dav_propdb *propdb,
 361 +                                             const char *ns_uri,
 362 +                                             const char *propname,
 363 +                                             apr_text_header *body)
 364  {
 365      int propid;
 366      const dav_hooks_liveprop *hooks;
 367 @@ -903,7 +905,7 @@
 368      }
 369  }
 370
 371 -void dav_prop_validate(dav_prop_ctx *ctx)
 372 +DAV_DECLARE_NONSTD(void) dav_prop_validate(dav_prop_ctx *ctx)
 373  {
 374      dav_propdb *propdb = ctx->propdb;
 375      apr_xml_elem *prop = ctx->prop;
 376 @@ -994,7 +996,7 @@
 377      }
 378  }
 379
 380 -void dav_prop_exec(dav_prop_ctx *ctx)
 381 +DAV_DECLARE_NONSTD(void) dav_prop_exec(dav_prop_ctx *ctx)
 382  {
 383      dav_propdb *propdb = ctx->propdb;
 384      dav_error *err = NULL;
 385 @@ -1060,7 +1062,7 @@
 386      }
 387  }
 388
 389 -void dav_prop_commit(dav_prop_ctx *ctx)
 390 +DAV_DECLARE_NONSTD(void) dav_prop_commit(dav_prop_ctx *ctx)
 391  {
 392      dav_elem_private *priv = ctx->prop->priv;
 393
 394 @@ -1077,7 +1079,7 @@
 395      }
 396  }
 397
 398 -void dav_prop_rollback(dav_prop_ctx *ctx)
 399 +DAV_DECLARE_NONSTD(void) dav_prop_rollback(dav_prop_ctx *ctx)
 400  {
 401      dav_error *err = NULL;
 402      dav_elem_private *priv = ctx->prop->priv;
 403 Index: modules/dav/main/util_lock.c
 404 ===================================================================
 405 --- modules/dav/main/util_lock.c        (revision 155344)
 406 +++ modules/dav/main/util_lock.c        (revision 155345)
 407 @@ -42,8 +42,9 @@
 408  ** dav_lock_get_activelock:  Returns a <lockdiscovery> containing
 409  **    an activelock element for every item in the lock_discovery tree
 410  */
 411 -const char *dav_lock_get_activelock(request_rec *r, dav_lock *lock,
 412 -                                    dav_buffer *pbuf)
 413 +DAV_DECLARE(const char *) dav_lock_get_activelock(request_rec *r,
 414 +                                                  dav_lock *lock,
 415 +                                                  dav_buffer *pbuf)
 416  {
 417      dav_lock *lock_scan;
 418      const dav_hooks_locks *hooks = DAV_GET_HOOKS_LOCKS(r);
 419 @@ -159,11 +160,11 @@
 420  **    lockinfo XML element, then populates a dav_lock structure
 421  **    with its contents.
 422  */
 423 -dav_error * dav_lock_parse_lockinfo(request_rec *r,
 424 -                                    const dav_resource *resource,
 425 -                                    dav_lockdb *lockdb,
 426 -                                    const apr_xml_doc *doc,
 427 -                                    dav_lock **lock_request)
 428 +DAV_DECLARE(dav_error *) dav_lock_parse_lockinfo(request_rec *r,
 429 +                                                 const dav_resource *resource,
 430 +                                                 dav_lockdb *lockdb,
 431 +                                                 const apr_xml_doc *doc,
 432 +                                                 dav_lock **lock_request)
 433  {
 434      apr_pool_t *p = r->pool;
 435      dav_error *err;
 436 @@ -285,9 +286,10 @@
 437  **    all children, bounded by depth.
 438  **    ### assume request only contains one lock
 439  */
 440 -dav_error * dav_add_lock(request_rec *r, const dav_resource *resource,
 441 -                         dav_lockdb *lockdb, dav_lock *lock,
 442 -                         dav_response **response)
 443 +DAV_DECLARE(dav_error *) dav_add_lock(request_rec *r,
 444 +                                      const dav_resource *resource,
 445 +                                      dav_lockdb *lockdb, dav_lock *lock,
 446 +                                      dav_response **response)
 447  {
 448      dav_error *err;
 449      int depth = lock->depth;
 450 @@ -485,8 +487,8 @@
 451  ** ### We've already crawled the tree to ensure everything was locked
 452  **     by us; there should be no need to incorporate a rollback.
 453  */
 454 -int dav_unlock(request_rec *r, const dav_resource *resource,
 455 -               const dav_locktoken *locktoken)
 456 +DAV_DECLARE(int) dav_unlock(request_rec *r, const dav_resource *resource,
 457 +                            const dav_locktoken *locktoken)
 458  {
 459      int result;
 460      dav_lockdb *lockdb;
 461 @@ -674,7 +676,8 @@
 462  **
 463  **    Returns DAV_RESOURCE_ERROR if an error occurs.
 464  */
 465 -int dav_get_resource_state(request_rec *r, const dav_resource *resource)
 466 +DAV_DECLARE(int) dav_get_resource_state(request_rec *r,
 467 +                                        const dav_resource *resource)
 468  {
 469      const dav_hooks_locks *hooks = DAV_GET_HOOKS_LOCKS(r);
 470
 471 @@ -732,11 +735,11 @@
 472      return DAV_RESOURCE_NULL;
 473  }
 474
 475 -dav_error * dav_notify_created(request_rec *r,
 476 -                               dav_lockdb *lockdb,
 477 -                               const dav_resource *resource,
 478 -                               int resource_state,
 479 -                               int depth)
 480 +DAV_DECLARE(dav_error *) dav_notify_created(request_rec *r,
 481 +                                            dav_lockdb *lockdb,
 482 +                                            const dav_resource *resource,
 483 +                                            int resource_state,
 484 +                                            int depth)
 485  {
 486      dav_error *err;
 487
 488 Index: modules/dav/main/mod_dav.c
 489 ===================================================================
 490 --- modules/dav/main/mod_dav.c  (revision 155344)
 491 +++ modules/dav/main/mod_dav.c  (revision 155345)
 492 @@ -212,27 +212,27 @@
 493      return conf->provider;
 494  }
 495
 496 -const dav_hooks_locks *dav_get_lock_hooks(request_rec *r)
 497 +DAV_DECLARE(const dav_hooks_locks *) dav_get_lock_hooks(request_rec *r)
 498  {
 499      return dav_get_provider(r)->locks;
 500  }
 501
 502 -const dav_hooks_propdb *dav_get_propdb_hooks(request_rec *r)
 503 +DAV_DECLARE(const dav_hooks_propdb *) dav_get_propdb_hooks(request_rec *r)
 504  {
 505      return dav_get_provider(r)->propdb;
 506  }
 507
 508 -const dav_hooks_vsn *dav_get_vsn_hooks(request_rec *r)
 509 +DAV_DECLARE(const dav_hooks_vsn *) dav_get_vsn_hooks(request_rec *r)
 510  {
 511      return dav_get_provider(r)->vsn;
 512  }
 513
 514 -const dav_hooks_binding *dav_get_binding_hooks(request_rec *r)
 515 +DAV_DECLARE(const dav_hooks_binding *) dav_get_binding_hooks(request_rec *r)
 516  {
 517      return dav_get_provider(r)->binding;
 518  }
 519
 520 -const dav_hooks_search *dav_get_search_hooks(request_rec *r)
 521 +DAV_DECLARE(const dav_hooks_search *) dav_get_search_hooks(request_rec *r)
 522  {
 523      return dav_get_provider(r)->search;
 524  }
 525 @@ -648,7 +648,7 @@
 526  }
 527
 528  /* ### move to dav_util? */
 529 -int dav_get_depth(request_rec *r, int def_depth)
 530 +DAV_DECLARE(int) dav_get_depth(request_rec *r, int def_depth)
 531  {
 532      const char *depth = apr_table_get(r->headers_in, "Depth");
 533
 534 Index: modules/dav/main/std_liveprop.c
 535 ===================================================================
 536 --- modules/dav/main/std_liveprop.c     (revision 155344)
 537 +++ modules/dav/main/std_liveprop.c     (revision 155345)
 538 @@ -169,22 +169,25 @@
 539      NULL,       /* patch_rollback */
 540  };
 541
 542 -int dav_core_find_liveprop(const dav_resource *resource,
 543 -                           const char *ns_uri, const char *name,
 544 -                           const dav_hooks_liveprop **hooks)
 545 +DAV_DECLARE_NONSTD(int) dav_core_find_liveprop(
 546 +    const dav_resource *resource,
 547 +    const char *ns_uri, const char *name,
 548 +    const dav_hooks_liveprop **hooks)
 549  {
 550      return dav_do_find_liveprop(ns_uri, name, &dav_core_liveprop_group, hooks);
 551  }
 552
 553 -void dav_core_insert_all_liveprops(request_rec *r,
 554 -                                   const dav_resource *resource,
 555 -                                   dav_prop_insert what, apr_text_header *phdr)
 556 +DAV_DECLARE_NONSTD(void) dav_core_insert_all_liveprops(
 557 +    request_rec *r,
 558 +    const dav_resource *resource,
 559 +    dav_prop_insert what,
 560 +    apr_text_header *phdr)
 561  {
 562      (void) dav_core_insert_prop(resource, DAV_PROPID_resourcetype,
 563                                  what, phdr);
 564  }
 565
 566 -void dav_core_register_uris(apr_pool_t *p)
 567 +DAV_DECLARE_NONSTD(void) dav_core_register_uris(apr_pool_t *p)
 568  {
 569      /* register the namespace URIs */
 570      dav_register_liveprop_group(p, &dav_core_liveprop_group);
 571 Index: modules/dav/main/providers.c
 572 ===================================================================
 573 --- modules/dav/main/providers.c        (revision 155344)
 574 +++ modules/dav/main/providers.c        (revision 155345)
 575 @@ -27,7 +27,7 @@
 576      ap_register_provider(p, DAV_PROVIDER_GROUP, name, "0", provider);
 577  }
 578
 579 -const dav_provider * dav_lookup_provider(const char *name)
 580 +DAV_DECLARE(const dav_provider *) dav_lookup_provider(const char *name)
 581  {
 582      return ap_lookup_provider(DAV_PROVIDER_GROUP, name, "0");
 583  }
 584 Index: modules/dav/main/util.c
 585 ===================================================================
 586 --- modules/dav/main/util.c     (revision 155344)
 587 +++ modules/dav/main/util.c     (revision 155345)
 588 @@ -159,8 +159,9 @@
 589  ** If NULL is returned, then an error occurred with parsing the URI or
 590  ** the URI does not match the current server.
 591  */
 592 -dav_lookup_result dav_lookup_uri(const char *uri, request_rec * r,
 593 -                                 int must_be_absolute)
 594 +DAV_DECLARE(dav_lookup_result) dav_lookup_uri(const char *uri,
 595 +                                              request_rec * r,
 596 +                                              int must_be_absolute)
 597  {
 598      dav_lookup_result result = { 0 };
 599      const char *scheme;
 600 @@ -287,7 +288,8 @@
 601  */
 602
 603  /* validate that the root element uses a given DAV: tagname (TRUE==valid) */
 604 -int dav_validate_root(const apr_xml_doc *doc, const char *tagname)
 605 +DAV_DECLARE(int) dav_validate_root(const apr_xml_doc *doc,
 606 +                                   const char *tagname)
 607  {
 608      return doc->root &&
 609          doc->root->ns == APR_XML_NS_DAV_ID &&
 610 @@ -295,7 +297,8 @@
 611  }
 612
 613  /* find and return the (unique) child with a given DAV: tagname */
 614 -apr_xml_elem *dav_find_child(const apr_xml_elem *elem, const char *tagname)
 615 +DAV_DECLARE(apr_xml_elem *) dav_find_child(const apr_xml_elem *elem,
 616 +                                           const char *tagname)
 617  {
 618      apr_xml_elem *child = elem->first_child;
 619
 620 @@ -461,7 +464,7 @@
 621   *    Seconds-xxx and Infinity time values.  We assume that they do.
 622   *    In addition, for now, that's all we understand, too.
 623   */
 624 -time_t dav_get_timeout(request_rec *r)
 625 +DAV_DECLARE(time_t) dav_get_timeout(request_rec *r)
 626  {
 627      time_t now, expires = DAV_TIMEOUT_INFINITE;
 628
 629 @@ -1402,10 +1405,13 @@
 630  ** On error, return appropriate HTTP_* code, and log error. If a multi-stat
 631  ** error is necessary, response will point to it, else NULL.
 632  */
 633 -dav_error * dav_validate_request(request_rec *r, dav_resource *resource,
 634 -                                 int depth, dav_locktoken *locktoken,
 635 -                                 dav_response **response, int flags,
 636 -                                 dav_lockdb *lockdb)
 637 +DAV_DECLARE(dav_error *) dav_validate_request(request_rec *r,
 638 +                                              dav_resource *resource,
 639 +                                              int depth,
 640 +                                              dav_locktoken *locktoken,
 641 +                                              dav_response **response,
 642 +                                              int flags,
 643 +                                              dav_lockdb *lockdb)
 644  {
 645      dav_error *err;
 646      int result;
 647 @@ -1623,7 +1629,8 @@
 648   * Sets ltl to a locktoken_list of all positive locktokens in header,
 649   * else NULL if no If-header, or no positive locktokens.
 650   */
 651 -dav_error * dav_get_locktoken_list(request_rec *r, dav_locktoken_list **ltl)
 652 +DAV_DECLARE(dav_error *) dav_get_locktoken_list(request_rec *r,
 653 +                                                dav_locktoken_list **ltl)
 654  {
 655      dav_error *err;
 656      dav_if_header *if_header;
 657 @@ -1693,9 +1700,9 @@
 658   * If there were any headers in the request which require a Vary header
 659   * in the response, add it.
 660   */
 661 -void dav_add_vary_header(request_rec *in_req,
 662 -                         request_rec *out_req,
 663 -                         const dav_resource *resource)
 664 +DAV_DECLARE(void) dav_add_vary_header(request_rec *in_req,
 665 +                                      request_rec *out_req,
 666 +                                      const dav_resource *resource)
 667  {
 668      const dav_hooks_vsn *vsn_hooks = DAV_GET_HOOKS_VSN(in_req);
 669
 670 @@ -1779,7 +1786,7 @@
 671  }
 672
 673  /* see mod_dav.h for docco */
 674 -dav_error *dav_auto_checkout(
 675 +DAV_DECLARE(dav_error *) dav_auto_checkout(
 676      request_rec *r,
 677      dav_resource *resource,
 678      int parent_only,
 679 @@ -1925,7 +1932,7 @@
 680  }
 681
 682  /* see mod_dav.h for docco */
 683 -dav_error *dav_auto_checkin(
 684 +DAV_DECLARE(dav_error *) dav_auto_checkin(
 685      request_rec *r,
 686      dav_resource *resource,
 687      int undo,