1 /* 2 * ra_serf.h : Private declarations for the Serf-based DAV RA module. 3 * 4 * ==================================================================== 5 * Licensed to the Apache Software Foundation (ASF) under one 6 * or more contributor license agreements. See the NOTICE file 7 * distributed with this work for additional information 8 * regarding copyright ownership. The ASF licenses this file 9 * to you under the Apache License, Version 2.0 (the 10 * "License"); you may not use this file except in compliance 11 * with the License. You may obtain a copy of the License at 12 * 13 * http://www.apache.org/licenses/LICENSE-2.0 14 * 15 * Unless required by applicable law or agreed to in writing, 16 * software distributed under the License is distributed on an 17 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 18 * KIND, either express or implied. See the License for the 19 * specific language governing permissions and limitations 20 * under the License. 21 * ==================================================================== 22 */ 23 24 #ifndef SVN_LIBSVN_RA_SERF_RA_SERF_H 25 #define SVN_LIBSVN_RA_SERF_RA_SERF_H 26 27 28 #include <serf.h> 29 #include <expat.h> /* for XML_Parser */ 30 #include <apr_uri.h> 31 32 #include "svn_types.h" 33 #include "svn_string.h" 34 #include "svn_pools.h" 35 #include "svn_ra.h" 36 #include "svn_delta.h" 37 #include "svn_version.h" 38 #include "svn_dav.h" 39 #include "svn_dirent_uri.h" 40 41 #include "private/svn_dav_protocol.h" 42 #include "private/svn_subr_private.h" 43 #include "private/svn_editor.h" 44 45 #include "blncache.h" 46 47 #ifdef __cplusplus 48 extern "C" { 49 #endif /* __cplusplus */ 50 51 52 /* Enforce the minimum version of serf. */ 53 #if !SERF_VERSION_AT_LEAST(1, 2, 1) 54 #error Please update your version of serf to at least 1.2.1. 55 #endif 56 57 /** Use this to silence compiler warnings about unused parameters. */ 58 #define UNUSED_CTX(x) ((void)(x)) 59 60 /** Wait duration (in microseconds) used in calls to serf_context_run() */ 61 #define SVN_RA_SERF__CONTEXT_RUN_DURATION 500000 62 63 64 65 /* Forward declarations. */ 66 typedef struct svn_ra_serf__session_t svn_ra_serf__session_t; 67 68 /* A serf connection and optionally associated SSL context. */ 69 typedef struct svn_ra_serf__connection_t { 70 /* Our connection to a server. */ 71 serf_connection_t *conn; 72 73 /* Bucket allocator for this connection. */ 74 serf_bucket_alloc_t *bkt_alloc; 75 76 /* Collected cert failures in chain. */ 77 int server_cert_failures; 78 79 /* What was the last HTTP status code we got on this connection? */ 80 int last_status_code; 81 82 /* Optional SSL context for this connection. */ 83 serf_ssl_context_t *ssl_context; 84 svn_auth_iterstate_t *ssl_client_auth_state; 85 svn_auth_iterstate_t *ssl_client_pw_auth_state; 86 87 svn_ra_serf__session_t *session; 88 89 } svn_ra_serf__connection_t; 90 91 /** Maximum value we'll allow for the http-max-connections config option. 92 * 93 * Note: minimum 2 connections are required for ra_serf to function 94 * correctly! 95 */ 96 #define SVN_RA_SERF__MAX_CONNECTIONS_LIMIT 8 97 98 /* 99 * The master serf RA session. 100 * 101 * This is stored in the ra session ->priv field. 102 */ 103 struct svn_ra_serf__session_t { 104 /* Pool for allocations during this session */ 105 apr_pool_t *pool; 106 107 /* The current context */ 108 serf_context_t *context; 109 110 /* The maximum number of connections we'll use for parallelized 111 fetch operations (updates, etc.) */ 112 apr_int64_t max_connections; 113 114 /* Are we using ssl */ 115 svn_boolean_t using_ssl; 116 117 /* Should we ask for compressed responses? */ 118 svn_boolean_t using_compression; 119 120 /* The user agent string */ 121 const char *useragent; 122 123 /* The current connection */ 124 svn_ra_serf__connection_t *conns[SVN_RA_SERF__MAX_CONNECTIONS_LIMIT]; 125 int num_conns; 126 int cur_conn; 127 128 /* The URL that was passed into _open() */ 129 apr_uri_t session_url; 130 const char *session_url_str; 131 132 /* The actual discovered root; may be NULL until we know it. */ 133 apr_uri_t repos_root; 134 const char *repos_root_str; 135 136 /* The server is not Apache/mod_dav_svn (directly) and only supports 137 HTTP/1.0. Thus, we cannot send chunked requests. */ 138 svn_boolean_t http10; 139 140 /* Should we use Transfer-Encoding: chunked for HTTP/1.1 servers. */ 141 svn_boolean_t using_chunked_requests; 142 143 /* Do we need to detect whether the connection supports chunked requests? 144 i.e. is there a (reverse) proxy that does not support them? */ 145 svn_boolean_t detect_chunking; 146 147 /* Our Version-Controlled-Configuration; may be NULL until we know it. */ 148 const char *vcc_url; 149 150 /* Authentication related properties. */ 151 svn_auth_iterstate_t *auth_state; 152 int auth_attempts; 153 154 /* Callback functions to get info from WC */ 155 const svn_ra_callbacks2_t *wc_callbacks; 156 void *wc_callback_baton; 157 158 /* Callback function to send progress info to the client */ 159 svn_ra_progress_notify_func_t progress_func; 160 void *progress_baton; 161 162 /* Callback function to handle cancellation */ 163 svn_cancel_func_t cancel_func; 164 void *cancel_baton; 165 166 /* Ev2 shim callbacks */ 167 svn_delta_shim_callbacks_t *shim_callbacks; 168 169 /* Error that we've received but not yet returned upstream. */ 170 svn_error_t *pending_error; 171 172 /* List of authn types supported by the client.*/ 173 int authn_types; 174 175 /* Maps SVN_RA_CAPABILITY_foo keys to "yes" or "no" values. 176 If a capability is not yet discovered, it is absent from the table. 177 The table itself is allocated in the svn_ra_serf__session_t's pool; 178 keys and values must have at least that lifetime. Most likely 179 the keys and values are constants anyway (and sufficiently 180 well-informed internal code may just compare against those 181 constants' addresses, therefore). */ 182 apr_hash_t *capabilities; 183 184 /* Activity collection URL. (Cached from the initial OPTIONS 185 request when run against HTTPv1 servers.) */ 186 const char *activity_collection_url; 187 188 /* Are we using a proxy? */ 189 svn_boolean_t using_proxy; 190 191 const char *proxy_username; 192 const char *proxy_password; 193 int proxy_auth_attempts; 194 195 /* SSL server certificates */ 196 svn_boolean_t trust_default_ca; 197 const char *ssl_authorities; 198 199 /* Repository UUID */ 200 const char *uuid; 201 202 /* Connection timeout value */ 203 apr_interval_time_t timeout; 204 205 /* HTTPv1 flags */ 206 svn_tristate_t supports_deadprop_count; 207 208 /*** HTTP v2 protocol stuff. *** 209 * 210 * We assume that if mod_dav_svn sends one of the special v2 OPTIONs 211 * response headers, it has sent all of them. Specifically, we'll 212 * be looking at the presence of the "me resource" as a flag that 213 * the server supports v2 of our HTTP protocol. 214 */ 215 216 /* The "me resource". Typically used as a target for REPORTs that 217 are path-agnostic. If we have this, we can speak HTTP v2 to the 218 server. */ 219 const char *me_resource; 220 221 /* Opaque URL "stubs". If the OPTIONS response returns these, then 222 we know we're using HTTP protocol v2. */ 223 const char *rev_stub; /* for accessing revisions (i.e. revprops) */ 224 const char *rev_root_stub; /* for accessing REV/PATH pairs */ 225 const char *txn_stub; /* for accessing transactions (i.e. txnprops) */ 226 const char *txn_root_stub; /* for accessing TXN/PATH pairs */ 227 const char *vtxn_stub; /* for accessing transactions (i.e. txnprops) */ 228 const char *vtxn_root_stub; /* for accessing TXN/PATH pairs */ 229 230 /* Hash mapping const char * server-supported POST types to 231 disinteresting-but-non-null values. */ 232 apr_hash_t *supported_posts; 233 234 /*** End HTTP v2 stuff ***/ 235 236 svn_ra_serf__blncache_t *blncache; 237 238 /* Trisate flag that indicates user preference for using bulk updates 239 (svn_tristate_true) with all the properties and content in the 240 update-report response. If svn_tristate_false, request a skelta 241 update-report with inlined properties. If svn_tristate_unknown then use 242 server preference. */ 243 svn_tristate_t bulk_updates; 244 245 /* Indicates if the server wants bulk update requests (Prefer) or only 246 accepts skelta requests (Off). If this value is On both options are 247 allowed. */ 248 const char *server_allows_bulk; 249 250 /* Indicates if the server supports sending inlined props in update editor 251 * in skelta mode (send-all == 'false'). */ 252 svn_boolean_t supports_inline_props; 253 254 /* Indicates whether the server supports issuing replay REPORTs 255 against rev resources (children of `rev_stub', elsestruct). */ 256 svn_boolean_t supports_rev_rsrc_replay; 257 }; 258 259 #define SVN_RA_SERF__HAVE_HTTPV2_SUPPORT(sess) ((sess)->me_resource != NULL) 260 261 /* 262 * Structure which represents a DAV element with a NAMESPACE and NAME. 263 */ 264 typedef struct svn_ra_serf__dav_props_t { 265 /* Element namespace */ 266 const char *namespace; 267 /* Element name */ 268 const char *name; 269 } svn_ra_serf__dav_props_t; 270 271 /* 272 * Structure which represents an XML namespace. 273 */ 274 typedef struct ns_t { 275 /* The assigned name. */ 276 const char *namespace; 277 /* The full URL for this namespace. */ 278 const char *url; 279 /* The next namespace in our list. */ 280 struct ns_t *next; 281 } svn_ra_serf__ns_t; 282 283 /* 284 * An incredibly simple list. 285 */ 286 typedef struct ra_serf_list_t { 287 void *data; 288 struct ra_serf_list_t *next; 289 } svn_ra_serf__list_t; 290 291 /** DAV property sets **/ 292 293 static const svn_ra_serf__dav_props_t base_props[] = 294 { 295 { "DAV:", "version-controlled-configuration" }, 296 { "DAV:", "resourcetype" }, 297 { SVN_DAV_PROP_NS_DAV, "baseline-relative-path" }, 298 { SVN_DAV_PROP_NS_DAV, "repository-uuid" }, 299 { NULL } 300 }; 301 302 static const svn_ra_serf__dav_props_t checked_in_props[] = 303 { 304 { "DAV:", "checked-in" }, 305 { NULL } 306 }; 307 308 static const svn_ra_serf__dav_props_t baseline_props[] = 309 { 310 { "DAV:", "baseline-collection" }, 311 { "DAV:", SVN_DAV__VERSION_NAME }, 312 { NULL } 313 }; 314 315 static const svn_ra_serf__dav_props_t all_props[] = 316 { 317 { "DAV:", "allprop" }, 318 { NULL } 319 }; 320 321 static const svn_ra_serf__dav_props_t check_path_props[] = 322 { 323 { "DAV:", "resourcetype" }, 324 { NULL } 325 }; 326 327 static const svn_ra_serf__dav_props_t type_and_checksum_props[] = 328 { 329 { "DAV:", "resourcetype" }, 330 { SVN_DAV_PROP_NS_DAV, "sha1-checksum" }, 331 { NULL } 332 }; 333 334 /* WC props compatibility with ra_neon. */ 335 #define SVN_RA_SERF__WC_CHECKED_IN_URL SVN_PROP_WC_PREFIX "ra_dav:version-url" 336 337 /** Serf utility functions **/ 338 339 apr_status_t 340 svn_ra_serf__conn_setup(apr_socket_t *sock, 341 serf_bucket_t **read_bkt, 342 serf_bucket_t **write_bkt, 343 void *baton, 344 apr_pool_t *pool); 345 346 void 347 svn_ra_serf__conn_closed(serf_connection_t *conn, 348 void *closed_baton, 349 apr_status_t why, 350 apr_pool_t *pool); 351 352 353 /* Helper function to provide SSL client certificates. 354 * 355 * NOTE: This function sets the session's 'pending_error' member when 356 * returning an non-success status. 357 */ 358 apr_status_t 359 svn_ra_serf__handle_client_cert(void *data, 360 const char **cert_path); 361 362 /* Helper function to provide SSL client certificate passwords. 363 * 364 * NOTE: This function sets the session's 'pending_error' member when 365 * returning an non-success status. 366 */ 367 apr_status_t 368 svn_ra_serf__handle_client_cert_pw(void *data, 369 const char *cert_path, 370 const char **password); 371 372 373 /* 374 * This function will run the serf context in SESS until *DONE is TRUE. 375 */ 376 svn_error_t * 377 svn_ra_serf__context_run_wait(svn_boolean_t *done, 378 svn_ra_serf__session_t *sess, 379 apr_pool_t *scratch_pool); 380 381 /* Callback for response handlers */ 382 typedef svn_error_t * 383 (*svn_ra_serf__response_handler_t)(serf_request_t *request, 384 serf_bucket_t *response, 385 void *handler_baton, 386 apr_pool_t *scratch_pool); 387 388 /* Callback for when a request body is needed. */ 389 /* ### should pass a scratch_pool */ 390 typedef svn_error_t * 391 (*svn_ra_serf__request_body_delegate_t)(serf_bucket_t **body_bkt, 392 void *baton, 393 serf_bucket_alloc_t *alloc, 394 apr_pool_t *request_pool); 395 396 /* Callback for when request headers are needed. */ 397 /* ### should pass a scratch_pool */ 398 typedef svn_error_t * 399 (*svn_ra_serf__request_header_delegate_t)(serf_bucket_t *headers, 400 void *baton, 401 apr_pool_t *request_pool); 402 403 /* Callback for when a response has an error. */ 404 typedef svn_error_t * 405 (*svn_ra_serf__response_error_t)(serf_request_t *request, 406 serf_bucket_t *response, 407 int status_code, 408 void *baton); 409 410 /* ### we should reorder the types in this file. */ 411 typedef struct svn_ra_serf__server_error_t svn_ra_serf__server_error_t; 412 413 /* 414 * Structure that can be passed to our default handler to guide the 415 * execution of the request through its lifecycle. 416 */ 417 typedef struct svn_ra_serf__handler_t { 418 /* The HTTP method string of the request */ 419 const char *method; 420 421 /* The resource to the execute the method on. */ 422 const char *path; 423 424 /* The content-type of the request body. */ 425 const char *body_type; 426 427 /* If TRUE then default Accept-Encoding request header is not configured for 428 request. If FALSE then 'gzip' accept encoding will be used if compression 429 enabled. */ 430 svn_boolean_t custom_accept_encoding; 431 432 /* Has the request/response been completed? */ 433 svn_boolean_t done; 434 435 /* If we captured an error from the server, then this will be non-NULL. 436 It will be allocated from HANDLER_POOL. */ 437 svn_ra_serf__server_error_t *server_error; 438 439 /* The handler and baton pair for our handler. */ 440 svn_ra_serf__response_handler_t response_handler; 441 void *response_baton; 442 443 /* When REPONSE_HANDLER is invoked, the following fields will be set 444 based on the response header. HANDLER_POOL must be non-NULL for these 445 values to be filled in. SLINE.REASON and LOCATION will be allocated 446 within HANDLER_POOL. */ 447 serf_status_line sline; /* The parsed Status-Line */ 448 const char *location; /* The Location: header, if any */ 449 450 /* The handler and baton pair to be executed when a non-recoverable error 451 * is detected. If it is NULL in the presence of an error, an abort() may 452 * be triggered. 453 */ 454 svn_ra_serf__response_error_t response_error; 455 void *response_error_baton; 456 457 /* This function and baton pair allows for custom request headers to 458 * be set. 459 * 460 * It will be executed after the request has been set up but before it is 461 * delivered. 462 */ 463 svn_ra_serf__request_header_delegate_t header_delegate; 464 void *header_delegate_baton; 465 466 /* This function and baton pair allows a body to be created right before 467 * delivery. 468 * 469 * It will be executed after the request has been set up but before it is 470 * delivered. 471 * 472 * May be NULL if there is no body to send. 473 * 474 */ 475 svn_ra_serf__request_body_delegate_t body_delegate; 476 void *body_delegate_baton; 477 478 /* The connection and session to be used for this request. */ 479 svn_ra_serf__connection_t *conn; 480 svn_ra_serf__session_t *session; 481 482 /* Internal flag to indicate we've parsed the headers. */ 483 svn_boolean_t reading_body; 484 485 /* When this flag will be set, the core handler will discard any unread 486 portion of the response body. The registered response handler will 487 no longer be called. */ 488 svn_boolean_t discard_body; 489 490 /* Pool for allocating SLINE.REASON and LOCATION. If this pool is NULL, 491 then the requestor does not care about SLINE and LOCATION. */ 492 apr_pool_t *handler_pool; 493 494 } svn_ra_serf__handler_t; 495 496 497 /* Run one request and process the response. 498 499 Similar to context_run_wait(), but this creates the request for HANDLER 500 and then waits for it to complete. 501 502 WARNING: context_run_wait() does NOT create a request, whereas this 503 function DOES. Avoid a double-create. */ 504 svn_error_t * 505 svn_ra_serf__context_run_one(svn_ra_serf__handler_t *handler, 506 apr_pool_t *scratch_pool); 507 508 509 /* 510 * Helper function to queue a request in the @a handler's connection. 511 */ 512 void svn_ra_serf__request_create(svn_ra_serf__handler_t *handler); 513 514 /* XML helper callbacks. */ 515 516 typedef struct svn_ra_serf__xml_state_t { 517 /* A numeric value that represents the current state in parsing. 518 * 519 * Value 0 is reserved for use as the default state. 520 */ 521 int current_state; 522 523 /* Private pointer set by the parsing code. */ 524 void *private; 525 526 /* Allocations should be made in this pool to match the lifetime of the 527 * state. 528 */ 529 apr_pool_t *pool; 530 531 /* The currently-declared namespace for this state. */ 532 svn_ra_serf__ns_t *ns_list; 533 534 /* Our previous states. */ 535 struct svn_ra_serf__xml_state_t *prev; 536 } svn_ra_serf__xml_state_t; 537 538 /* Forward declaration of the XML parser structure. */ 539 typedef struct svn_ra_serf__xml_parser_t svn_ra_serf__xml_parser_t; 540 541 /* Callback invoked with @a baton by our XML @a parser when an element with 542 * the @a name containing @a attrs is opened. 543 */ 544 typedef svn_error_t * 545 (*svn_ra_serf__xml_start_element_t)(svn_ra_serf__xml_parser_t *parser, 546 svn_ra_serf__dav_props_t name, 547 const char **attrs, 548 apr_pool_t *scratch_pool); 549 550 /* Callback invoked with @a baton by our XML @a parser when an element with 551 * the @a name is closed. 552 */ 553 typedef svn_error_t * 554 (*svn_ra_serf__xml_end_element_t)(svn_ra_serf__xml_parser_t *parser, 555 svn_ra_serf__dav_props_t name, 556 apr_pool_t *scratch_pool); 557 558 /* Callback invoked with @a baton by our XML @a parser when a CDATA portion 559 * of @a data with size @a len is encountered. 560 * 561 * This may be invoked multiple times for the same tag. 562 */ 563 typedef svn_error_t * 564 (*svn_ra_serf__xml_cdata_chunk_handler_t)(svn_ra_serf__xml_parser_t *parser, 565 const char *data, 566 apr_size_t len, 567 apr_pool_t *scratch_pool); 568 569 /* 570 * Helper structure associated with handle_xml_parser handler that will 571 * specify how an XML response will be processed. 572 */ 573 struct svn_ra_serf__xml_parser_t { 574 /* Temporary allocations should be made in this pool. */ 575 apr_pool_t *pool; 576 577 /* What kind of response are we parsing? If set, this should typically 578 define the report name. */ 579 const char *response_type; 580 581 /* Caller-specific data passed to the start, end, cdata callbacks. */ 582 void *user_data; 583 584 /* Callback invoked when a tag is opened. */ 585 svn_ra_serf__xml_start_element_t start; 586 587 /* Callback invoked when a tag is closed. */ 588 svn_ra_serf__xml_end_element_t end; 589 590 /* Callback invoked when a cdata chunk is received. */ 591 svn_ra_serf__xml_cdata_chunk_handler_t cdata; 592 593 /* Our associated expat-based XML parser. */ 594 XML_Parser xmlp; 595 596 /* Our current state. */ 597 svn_ra_serf__xml_state_t *state; 598 599 /* Our previously used states (will be reused). */ 600 svn_ra_serf__xml_state_t *free_state; 601 602 /* If non-NULL, this value will be set to TRUE when the response is 603 * completed. 604 */ 605 svn_boolean_t *done; 606 607 /* If non-NULL, when this parser completes, it will add done_item to 608 * the list. 609 */ 610 svn_ra_serf__list_t **done_list; 611 612 /* A pointer to the item that will be inserted into the list upon 613 * completeion. 614 */ 615 svn_ra_serf__list_t *done_item; 616 617 /* If this flag is TRUE, errors during parsing will be ignored. 618 * 619 * This is mainly used when we are processing an error XML response to 620 * avoid infinite loops. 621 */ 622 svn_boolean_t ignore_errors; 623 624 /* If an error occurred, this value will be non-NULL. */ 625 svn_error_t *error; 626 627 /* Deciding whether to pause, or not, is performed within the parsing 628 callbacks. If a callback decides to set this flag, then the loop 629 driving the parse (generally, a series of calls to serf_context_run()) 630 is going to need to coordinate the un-pausing of the parser by 631 processing pending content. Thus, deciding to pause the parser is a 632 coordinate effort rather than merely setting this flag. 633 634 When an XML parsing callback sets this flag, note that additional 635 elements may be parsed (as the current buffer is consumed). At some 636 point, the flag will be recognized and arriving network content will 637 be stashed away in the PENDING structure (see below). 638 639 At some point, the controlling loop should clear this value. The 640 underlying network processing will note the change and begin passing 641 content into the XML callbacks. 642 643 Note that the controlling loop should also process pending content 644 since the arriving network content will typically finish first. */ 645 svn_boolean_t paused; 646 647 /* While the XML parser is paused, content arriving from the server 648 must be saved locally. We cannot stop reading, or the server may 649 decide to drop the connection. The content will be stored in memory 650 up to a certain limit, and will then be spilled over to disk. 651 652 See libsvn_ra_serf/util.c */ 653 struct svn_ra_serf__pending_t *pending; 654 }; 655 656 657 /* v2 of the XML parsing functions */ 658 659 /* The XML parsing context. */ 660 typedef struct svn_ra_serf__xml_context_t svn_ra_serf__xml_context_t; 661 662 663 /* An opaque structure for the XML parse element/state. */ 664 typedef struct svn_ra_serf__xml_estate_t svn_ra_serf__xml_estate_t; 665 666 /* Called just after the parser moves into ENTERED_STATE. The tag causing 667 the transition is passed in TAG. 668 669 This callback is applied to a parsing context by using the 670 svn_ra_serf__xml_context_customize() function. 671 672 NOTE: this callback, when set, will be invoked on *every* transition. 673 The callback must examine ENTERED_STATE to determine if any action 674 must be taken. The original state is not provided, but must be derived 675 from ENTERED_STATE and/or the TAG causing the transition (if needed). */ 676 typedef svn_error_t * 677 (*svn_ra_serf__xml_opened_t)(svn_ra_serf__xml_estate_t *xes, 678 void *baton, 679 int entered_state, 680 const svn_ra_serf__dav_props_t *tag, 681 apr_pool_t *scratch_pool); 682 683 684 /* Called just before the parser leaves LEAVING_STATE. 685 686 If cdata collection was enabled for this state, then CDATA will be 687 non-NULL and contain the collected cdata. 688 689 If attribute collection was enabled for this state, then ATTRS will 690 contain the attributes collected for this element only, along with 691 any values stored via svn_ra_serf__xml_note(). 692 693 Use svn_ra_serf__xml_gather_since() to gather up data from outer states. 694 695 ATTRS is char* -> char*. 696 697 Temporary allocations may be made in SCRATCH_POOL. */ 698 typedef svn_error_t * 699 (*svn_ra_serf__xml_closed_t)(svn_ra_serf__xml_estate_t *xes, 700 void *baton, 701 int leaving_state, 702 const svn_string_t *cdata, 703 apr_hash_t *attrs, 704 apr_pool_t *scratch_pool); 705 706 707 /* Called for all states that are not using the builtin cdata collection. 708 This callback is (only) appropriate for unbounded-size cdata content. 709 710 CURRENT_STATE may be used to decide what to do with the data. 711 712 Temporary allocations may be made in SCRATCH_POOL. */ 713 typedef svn_error_t * 714 (*svn_ra_serf__xml_cdata_t)(svn_ra_serf__xml_estate_t *xes, 715 void *baton, 716 int current_state, 717 const char *data, 718 apr_size_t len, 719 apr_pool_t *scratch_pool); 720 721 722 /* State transition table. 723 724 When the XML Context is constructed, it is in state 0. User states are 725 positive integers. 726 727 In a list of transitions, use { 0 } to indicate the end. Specifically, 728 the code looks for NS == NULL. 729 730 ### more docco 731 */ 732 typedef struct svn_ra_serf__xml_transition_t { 733 /* This transition applies when in this state */ 734 int from_state; 735 736 /* And when this tag is observed */ 737 const char *ns; 738 const char *name; 739 740 /* Moving to this state */ 741 int to_state; 742 743 /* Should the cdata of NAME be collected? Note that CUSTOM_CLOSE should 744 be TRUE in order to capture this cdata. */ 745 svn_boolean_t collect_cdata; 746 747 /* Which attributes of NAME should be collected? Terminate with NULL. 748 Maximum of 10 attributes may be collected. Note that attribute 749 namespaces are ignored at this time. 750 751 Attribute names beginning with "?" are optional. Other names must 752 exist on the element, or SVN_ERR_XML_ATTRIB_NOT_FOUND will be raised. */ 753 const char *collect_attrs[11]; 754 755 /* When NAME is closed, should the callback be invoked? */ 756 svn_boolean_t custom_close; 757 758 } svn_ra_serf__xml_transition_t; 759 760 761 /* Construct an XML parsing context, based on the TTABLE transition table. 762 As content is parsed, the CLOSED_CB callback will be invoked according 763 to the definition in the table. 764 765 If OPENED_CB is not NULL, then it will be invoked for *every* tag-open 766 event. The callback will need to use the ENTERED_STATE and TAG parameters 767 to decide what it would like to do. 768 769 If CDATA_CB is not NULL, then it will be called for all cdata that is 770 not be automatically collected (based on the transition table record's 771 COLLECT_CDATA flag). It will be called in every state, so the callback 772 must examine the CURRENT_STATE parameter to decide what to do. 773 774 The same BATON value will be passed to all three callbacks. 775 776 The context will be created within RESULT_POOL. */ 777 svn_ra_serf__xml_context_t * 778 svn_ra_serf__xml_context_create( 779 const svn_ra_serf__xml_transition_t *ttable, 780 svn_ra_serf__xml_opened_t opened_cb, 781 svn_ra_serf__xml_closed_t closed_cb, 782 svn_ra_serf__xml_cdata_t cdata_cb, 783 void *baton, 784 apr_pool_t *result_pool); 785 786 /* Destroy all subpools for this structure. */ 787 void 788 svn_ra_serf__xml_context_destroy( 789 svn_ra_serf__xml_context_t *xmlctx); 790 791 /* Construct a handler with the response function/baton set up to parse 792 a response body using the given XML context. The handler and its 793 internal structures are allocated in RESULT_POOL. 794 795 This also initializes HANDLER_POOL to the given RESULT_POOL. */ 796 svn_ra_serf__handler_t * 797 svn_ra_serf__create_expat_handler(svn_ra_serf__xml_context_t *xmlctx, 798 apr_pool_t *result_pool); 799 800 801 /* Allocated within XES->STATE_POOL. Changes are not allowd (callers 802 should make a deep copy if they need to make changes). 803 804 The resulting hash maps char* names to char* values. */ 805 apr_hash_t * 806 svn_ra_serf__xml_gather_since(svn_ra_serf__xml_estate_t *xes, 807 int stop_state); 808 809 810 /* Attach the NAME/VALUE pair onto this/parent state identified by STATE. 811 The name and value will be copied into the target state's pool. 812 813 These values will be available to the CLOSED_CB for the target state, 814 or part of the gathered state via xml_gather_since(). 815 816 Typically, this function is used by a child state's close callback, 817 or within an opening callback to store additional data. 818 819 Note: if the state is not found, then a programmer error has occurred, 820 so the function will invoke SVN_ERR_MALFUNCTION(). */ 821 void 822 svn_ra_serf__xml_note(svn_ra_serf__xml_estate_t *xes, 823 int state, 824 const char *name, 825 const char *value); 826 827 828 /* Returns XES->STATE_POOL for allocating structures that should live 829 as long as the state identified by XES. 830 831 Note: a state pool is created upon demand, so only use this function 832 when memory is required for a given state. */ 833 apr_pool_t * 834 svn_ra_serf__xml_state_pool(svn_ra_serf__xml_estate_t *xes); 835 836 837 /* Any XML parser may be used. When an opening tag is seen, call this 838 function to feed the information into XMLCTX. */ 839 svn_error_t * 840 svn_ra_serf__xml_cb_start(svn_ra_serf__xml_context_t *xmlctx, 841 const char *raw_name, 842 const char *const *attrs); 843 844 845 /* When a close tag is seen, call this function to feed the information 846 into XMLCTX. */ 847 svn_error_t * 848 svn_ra_serf__xml_cb_end(svn_ra_serf__xml_context_t *xmlctx, 849 const char *raw_name); 850 851 852 /* When cdata is parsed by the wrapping XML parser, call this function to 853 feed the cdata into the XMLCTX. */ 854 svn_error_t * 855 svn_ra_serf__xml_cb_cdata(svn_ra_serf__xml_context_t *xmlctx, 856 const char *data, 857 apr_size_t len); 858 859 860 /* 861 * Parses a server-side error message into a local Subversion error. 862 */ 863 struct svn_ra_serf__server_error_t { 864 /* Our local representation of the error. */ 865 svn_error_t *error; 866 867 /* Are we done with the response? */ 868 svn_boolean_t done; 869 870 /* Have we seen an error tag? */ 871 svn_boolean_t in_error; 872 873 /* Have we seen a HTTP "412 Precondition Failed" error? */ 874 svn_boolean_t contains_precondition_error; 875 876 /* Should we be collecting the XML cdata? */ 877 svn_boolean_t collect_cdata; 878 879 /* Collected cdata. NULL if cdata not needed. */ 880 svn_stringbuf_t *cdata; 881 882 /* XML parser and namespace used to parse the remote response */ 883 svn_ra_serf__xml_parser_t parser; 884 }; 885 886 887 /* 888 * Handler that discards the entire @a response body associated with a 889 * @a request. Implements svn_ra_serf__response_handler_t. 890 * 891 * If @a baton is a svn_ra_serf__server_error_t (i.e. non-NULL) and an 892 * error is detected, it will be populated for later detection. 893 * 894 * All temporary allocations will be made in a @a pool. 895 */ 896 svn_error_t * 897 svn_ra_serf__handle_discard_body(serf_request_t *request, 898 serf_bucket_t *response, 899 void *baton, 900 apr_pool_t *pool); 901 902 903 /* 904 * Handler that retrieves the embedded XML multistatus response from the 905 * the @a RESPONSE body associated with a @a REQUEST. 906 * 907 * Implements svn_ra_serf__response_handler_t. 908 * 909 * The @a BATON should be of type svn_ra_serf__handler_t. When the request 910 * is complete, the handler's DONE flag will be set to TRUE. 911 * 912 * All temporary allocations will be made in a @a scratch_pool. 913 */ 914 svn_error_t * 915 svn_ra_serf__handle_multistatus_only(serf_request_t *request, 916 serf_bucket_t *response, 917 void *baton, 918 apr_pool_t *scratch_pool); 919 920 921 /* Handler that expects an empty body. 922 923 If a body IS present, and it is text/xml, then it will be parsed for 924 a server-side error. 925 926 BATON should be the svn_ra_serf__handler_t running REQUEST. 927 928 Status line information will be in HANDLER->SLINE. 929 930 Any parsed errors will be left in HANDLER->SERVER_ERROR. That member 931 may be NULL if no body was present, or a problem occurred trying to 932 parse the body. 933 934 All temporary allocations will be made in SCRATCH_POOL. */ 935 svn_error_t * 936 svn_ra_serf__expect_empty_body(serf_request_t *request, 937 serf_bucket_t *response, 938 void *baton, 939 apr_pool_t *scratch_pool); 940 941 942 /* 943 * This function will feed the RESPONSE body into XMLP. When parsing is 944 * completed (i.e. an EOF is received), *DONE is set to TRUE. 945 * Implements svn_ra_serf__response_handler_t. 946 * 947 * If an error occurs during processing RESP_ERR is invoked with the 948 * RESP_ERR_BATON. 949 * 950 * Temporary allocations are made in POOL. 951 */ 952 svn_error_t * 953 svn_ra_serf__handle_xml_parser(serf_request_t *request, 954 serf_bucket_t *response, 955 void *handler_baton, 956 apr_pool_t *pool); 957 958 /* serf_response_handler_t implementation that completely discards 959 * the response. 960 * 961 * All temporary allocations will be made in @a pool. 962 */ 963 apr_status_t 964 svn_ra_serf__response_discard_handler(serf_request_t *request, 965 serf_bucket_t *response, 966 void *baton, 967 apr_pool_t *pool); 968 969 970 /** XML helper functions. **/ 971 972 /* 973 * Advance the internal XML @a parser to the @a state. 974 */ 975 void 976 svn_ra_serf__xml_push_state(svn_ra_serf__xml_parser_t *parser, 977 int state); 978 979 /* 980 * Return to the previous internal XML @a parser state. 981 */ 982 void 983 svn_ra_serf__xml_pop_state(svn_ra_serf__xml_parser_t *parser); 984 985 986 svn_error_t * 987 svn_ra_serf__process_pending(svn_ra_serf__xml_parser_t *parser, 988 svn_boolean_t *network_eof, 989 apr_pool_t *scratch_pool); 990 991 992 /* 993 * Add the appropriate serf buckets to @a agg_bucket represented by 994 * the XML * @a tag and @a value. 995 * 996 * The bucket will be allocated from @a bkt_alloc. 997 */ 998 void 999 svn_ra_serf__add_tag_buckets(serf_bucket_t *agg_bucket, 1000 const char *tag, 1001 const char *value, 1002 serf_bucket_alloc_t *bkt_alloc); 1003 1004 /* 1005 * Add the appropriate serf buckets to AGG_BUCKET with standard XML header: 1006 * <?xml version="1.0" encoding="utf-8"?> 1007 * 1008 * The bucket will be allocated from BKT_ALLOC. 1009 */ 1010 void 1011 svn_ra_serf__add_xml_header_buckets(serf_bucket_t *agg_bucket, 1012 serf_bucket_alloc_t *bkt_alloc); 1013 1014 /* 1015 * Add the appropriate serf buckets to AGG_BUCKET representing the XML 1016 * open tag with name TAG. 1017 * 1018 * Take the tag's attributes from varargs, a NULL-terminated list of 1019 * alternating <tt>char *</tt> key and <tt>char *</tt> val. Attribute 1020 * will be ignored if it's value is NULL. 1021 * 1022 * NOTE: Callers are responsible for XML-escaping attribute values as 1023 * necessary. 1024 * 1025 * The bucket will be allocated from BKT_ALLOC. 1026 */ 1027 void 1028 svn_ra_serf__add_open_tag_buckets(serf_bucket_t *agg_bucket, 1029 serf_bucket_alloc_t *bkt_alloc, 1030 const char *tag, 1031 ...); 1032 1033 /* 1034 * Add the appropriate serf buckets to AGG_BUCKET representing xml tag close 1035 * with name TAG. 1036 * 1037 * The bucket will be allocated from BKT_ALLOC. 1038 */ 1039 void 1040 svn_ra_serf__add_close_tag_buckets(serf_bucket_t *agg_bucket, 1041 serf_bucket_alloc_t *bkt_alloc, 1042 const char *tag); 1043 1044 /* 1045 * Add the appropriate serf buckets to AGG_BUCKET with xml-escaped 1046 * version of DATA. 1047 * 1048 * The bucket will be allocated from BKT_ALLOC. 1049 */ 1050 void 1051 svn_ra_serf__add_cdata_len_buckets(serf_bucket_t *agg_bucket, 1052 serf_bucket_alloc_t *bkt_alloc, 1053 const char *data, apr_size_t len); 1054 /* 1055 * Look up the @a attrs array for namespace definitions and add each one 1056 * to the @a ns_list of namespaces. 1057 * 1058 * New namespaces will be allocated in RESULT_POOL. 1059 */ 1060 void 1061 svn_ra_serf__define_ns(svn_ra_serf__ns_t **ns_list, 1062 const char *const *attrs, 1063 apr_pool_t *result_pool); 1064 1065 /* 1066 * Look up @a name in the @a ns_list list for previously declared namespace 1067 * definitions. 1068 * 1069 * Return (in @a *returned_prop_name) a #svn_ra_serf__dav_props_t tuple 1070 * representing the expanded name. 1071 */ 1072 void 1073 svn_ra_serf__expand_ns(svn_ra_serf__dav_props_t *returned_prop_name, 1074 const svn_ra_serf__ns_t *ns_list, 1075 const char *name); 1076 1077 1078 /** PROPFIND-related functions **/ 1079 1080 /* 1081 * This function will deliver a PROP_CTX PROPFIND request in the SESS 1082 * serf context for the properties listed in LOOKUP_PROPS at URL for 1083 * DEPTH ("0","1","infinity"). 1084 * 1085 * This function will not block waiting for the response. Callers are 1086 * expected to call svn_ra_serf__wait_for_props(). 1087 */ 1088 svn_error_t * 1089 svn_ra_serf__deliver_props(svn_ra_serf__handler_t **propfind_handler, 1090 apr_hash_t *prop_vals, 1091 svn_ra_serf__session_t *sess, 1092 svn_ra_serf__connection_t *conn, 1093 const char *url, 1094 svn_revnum_t rev, 1095 const char *depth, 1096 const svn_ra_serf__dav_props_t *lookup_props, 1097 svn_ra_serf__list_t **done_list, 1098 apr_pool_t *pool); 1099 1100 /* 1101 * This helper function will block until PROPFIND_HANDLER indicates that is 1102 * done or another error is returned. 1103 */ 1104 svn_error_t * 1105 svn_ra_serf__wait_for_props(svn_ra_serf__handler_t *handler, 1106 apr_pool_t *scratch_pool); 1107 1108 /* This is a blocking version of deliver_props. 1109 1110 The properties are fetched and placed into RESULTS, allocated in 1111 RESULT_POOL. 1112 1113 ### more docco about the other params. 1114 1115 Temporary allocations are made in SCRATCH_POOL. 1116 */ 1117 svn_error_t * 1118 svn_ra_serf__retrieve_props(apr_hash_t **results, 1119 svn_ra_serf__session_t *sess, 1120 svn_ra_serf__connection_t *conn, 1121 const char *url, 1122 svn_revnum_t rev, 1123 const char *depth, 1124 const svn_ra_serf__dav_props_t *props, 1125 apr_pool_t *result_pool, 1126 apr_pool_t *scratch_pool); 1127 1128 1129 /* Using CONN, fetch the properties specified by WHICH_PROPS using CONN 1130 for URL at REVISION. The resulting properties are placed into a 2-level 1131 hash in RESULTS, mapping NAMESPACE -> hash<PROPNAME, PROPVALUE>, which 1132 is allocated in RESULT_POOL. 1133 1134 If REVISION is SVN_INVALID_REVNUM, then the properties are fetched 1135 from HEAD for URL. 1136 1137 This function performs the request synchronously. 1138 1139 Temporary allocations are made in SCRATCH_POOL. */ 1140 svn_error_t * 1141 svn_ra_serf__fetch_node_props(apr_hash_t **results, 1142 svn_ra_serf__connection_t *conn, 1143 const char *url, 1144 svn_revnum_t revision, 1145 const svn_ra_serf__dav_props_t *which_props, 1146 apr_pool_t *result_pool, 1147 apr_pool_t *scratch_pool); 1148 1149 1150 /* Using CONN, fetch a DAV: property from the resource identified by URL 1151 within REVISION. The PROPNAME may be one of: 1152 1153 "checked-in" 1154 "href" 1155 1156 The resulting value will be allocated in RESULT_POOL, and may be NULL 1157 if the property does not exist (note: "href" always exists). 1158 1159 This function performs the request synchronously. 1160 1161 Temporary allocations are made in SCRATCH_POOL. */ 1162 svn_error_t * 1163 svn_ra_serf__fetch_dav_prop(const char **value, 1164 svn_ra_serf__connection_t *conn, 1165 const char *url, 1166 svn_revnum_t revision, 1167 const char *propname, 1168 apr_pool_t *result_pool, 1169 apr_pool_t *scratch_pool); 1170 1171 1172 /* Set PROPS for PATH at REV revision with a NS:NAME VAL. 1173 * 1174 * The POOL governs allocation. 1175 */ 1176 void 1177 svn_ra_serf__set_ver_prop(apr_hash_t *props, 1178 const char *path, svn_revnum_t rev, 1179 const char *ns, const char *name, 1180 const svn_string_t *val, apr_pool_t *pool); 1181 #define svn_ra_serf__set_rev_prop svn_ra_serf__set_ver_prop 1182 1183 /** Property walker functions **/ 1184 1185 typedef svn_error_t * 1186 (*svn_ra_serf__walker_visitor_t)(void *baton, 1187 const char *ns, 1188 const char *name, 1189 const svn_string_t *val, 1190 apr_pool_t *pool); 1191 1192 svn_error_t * 1193 svn_ra_serf__walk_all_props(apr_hash_t *props, 1194 const char *name, 1195 svn_revnum_t rev, 1196 svn_ra_serf__walker_visitor_t walker, 1197 void *baton, 1198 apr_pool_t *pool); 1199 1200 1201 /* Like walk_all_props(), but a 2-level hash. */ 1202 svn_error_t * 1203 svn_ra_serf__walk_node_props(apr_hash_t *props, 1204 svn_ra_serf__walker_visitor_t walker, 1205 void *baton, 1206 apr_pool_t *scratch_pool); 1207 1208 1209 typedef svn_error_t * 1210 (*svn_ra_serf__path_rev_walker_t)(void *baton, 1211 const char *path, apr_ssize_t path_len, 1212 const char *ns, apr_ssize_t ns_len, 1213 const char *name, apr_ssize_t name_len, 1214 const svn_string_t *val, 1215 apr_pool_t *pool); 1216 svn_error_t * 1217 svn_ra_serf__walk_all_paths(apr_hash_t *props, 1218 svn_revnum_t rev, 1219 svn_ra_serf__path_rev_walker_t walker, 1220 void *baton, 1221 apr_pool_t *pool); 1222 1223 1224 /* Map a property name, as passed over the wire, into its corresponding 1225 Subversion-internal name. The returned name will be a static value, 1226 or allocated within RESULT_POOL. 1227 1228 If the property should be ignored (eg. some DAV properties), then NULL 1229 will be returned. */ 1230 const char * 1231 svn_ra_serf__svnname_from_wirename(const char *ns, 1232 const char *name, 1233 apr_pool_t *result_pool); 1234 1235 1236 /* Select the basic revision properties from the set of "all" properties. 1237 Return these in *REVPROPS, allocated from RESULT_POOL. */ 1238 svn_error_t * 1239 svn_ra_serf__select_revprops(apr_hash_t **revprops, 1240 const char *name, 1241 svn_revnum_t rev, 1242 apr_hash_t *all_revprops, 1243 apr_pool_t *result_pool, 1244 apr_pool_t *scratch_pool); 1245 1246 1247 /* PROPS is nested hash tables mapping NS -> NAME -> VALUE. 1248 This function takes the NS:NAME:VALUE hashes and flattens them into a set of 1249 names to VALUE. The names are composed of NS:NAME, with specific 1250 rewrite from wire names (DAV) to SVN names. This mapping is managed 1251 by the svn_ra_serf__set_baton_props() function. 1252 1253 FLAT_PROPS is allocated in RESULT_POOL. 1254 ### right now, we do a shallow copy from PROPS to FLAT_PROPS. therefore, 1255 ### the names and values in PROPS must be in the proper pool. 1256 1257 Temporary allocations are made in SCRATCH_POOL. */ 1258 svn_error_t * 1259 svn_ra_serf__flatten_props(apr_hash_t **flat_props, 1260 apr_hash_t *props, 1261 apr_pool_t *result_pool, 1262 apr_pool_t *scratch_pool); 1263 1264 1265 /* Return the property value for PATH at REV revision with a NS:NAME. 1266 * PROPS is a four-level nested hash: (svn_revnum_t => char *path => 1267 * char *ns => char *name => svn_string_t *). */ 1268 const svn_string_t * 1269 svn_ra_serf__get_ver_prop_string(apr_hash_t *props, 1270 const char *path, svn_revnum_t rev, 1271 const char *ns, const char *name); 1272 1273 /* Same as svn_ra_serf__get_ver_prop_string(), but returns a C string. */ 1274 const char * 1275 svn_ra_serf__get_ver_prop(apr_hash_t *props, 1276 const char *path, svn_revnum_t rev, 1277 const char *ns, const char *name); 1278 1279 /* Same as svn_ra_serf__get_ver_prop_string(), but for the unknown revision. */ 1280 const svn_string_t * 1281 svn_ra_serf__get_prop_string(apr_hash_t *props, 1282 const char *path, 1283 const char *ns, 1284 const char *name); 1285 1286 /* Same as svn_ra_serf__get_ver_prop(), but for the unknown revision. */ 1287 const char * 1288 svn_ra_serf__get_prop(apr_hash_t *props, 1289 const char *path, 1290 const char *ns, 1291 const char *name); 1292 1293 /* Same as svn_ra_serf__set_rev_prop(), but for the unknown revision. */ 1294 void 1295 svn_ra_serf__set_prop(apr_hash_t *props, const char *path, 1296 const char *ns, const char *name, 1297 const svn_string_t *val, apr_pool_t *pool); 1298 1299 svn_error_t * 1300 svn_ra_serf__get_resource_type(svn_node_kind_t *kind, 1301 apr_hash_t *props); 1302 1303 1304 /** MERGE-related functions **/ 1305 1306 void 1307 svn_ra_serf__merge_lock_token_list(apr_hash_t *lock_tokens, 1308 const char *parent, 1309 serf_bucket_t *body, 1310 serf_bucket_alloc_t *alloc, 1311 apr_pool_t *pool); 1312 1313 /* Create an MERGE request aimed at the SESSION url, requesting the 1314 merge of the resource identified by MERGE_RESOURCE_URL. 1315 LOCK_TOKENS is a hash mapping paths to lock tokens owned by the 1316 client. If KEEP_LOCKS is set, instruct the server to not release 1317 locks set on the paths included in this commit. */ 1318 svn_error_t * 1319 svn_ra_serf__run_merge(const svn_commit_info_t **commit_info, 1320 int *response_code, 1321 svn_ra_serf__session_t *session, 1322 svn_ra_serf__connection_t *conn, 1323 const char *merge_resource_url, 1324 apr_hash_t *lock_tokens, 1325 svn_boolean_t keep_locks, 1326 apr_pool_t *result_pool, 1327 apr_pool_t *scratch_pool); 1328 1329 1330 /** OPTIONS-related functions **/ 1331 1332 /* When running with a proxy, we may need to detect and correct for problems. 1333 This probing function will send a simple OPTIONS request to detect problems 1334 with the connection. */ 1335 svn_error_t * 1336 svn_ra_serf__probe_proxy(svn_ra_serf__session_t *serf_sess, 1337 apr_pool_t *scratch_pool); 1338 1339 1340 /* On HTTPv2 connections, run an OPTIONS request over CONN to fetch the 1341 current youngest revnum, returning it in *YOUNGEST. 1342 1343 (the revnum is headers of the OPTIONS response) 1344 1345 This function performs the request synchronously. 1346 1347 All temporary allocations will be made in SCRATCH_POOL. */ 1348 svn_error_t * 1349 svn_ra_serf__v2_get_youngest_revnum(svn_revnum_t *youngest, 1350 svn_ra_serf__connection_t *conn, 1351 apr_pool_t *scratch_pool); 1352 1353 1354 /* On HTTPv1 connections, run an OPTIONS request over CONN to fetch the 1355 activity collection set and return it in *ACTIVITY_URL, allocated 1356 from RESULT_POOL. 1357 1358 (the activity-collection-set is in the body of the OPTIONS response) 1359 1360 This function performs the request synchronously. 1361 1362 All temporary allocations will be made in SCRATCH_POOL. */ 1363 svn_error_t * 1364 svn_ra_serf__v1_get_activity_collection(const char **activity_url, 1365 svn_ra_serf__connection_t *conn, 1366 apr_pool_t *result_pool, 1367 apr_pool_t *scratch_pool); 1368 1369 1370 /* Set @a VCC_URL to the default VCC for our repository based on @a 1371 * ORIG_PATH for the session @a SESSION, ensuring that the VCC URL and 1372 * repository root URLs are cached in @a SESSION. Use @a CONN for any 1373 * required network communications if it is non-NULL; otherwise use the 1374 * default connection. 1375 * 1376 * All temporary allocations will be made in @a POOL. */ 1377 svn_error_t * 1378 svn_ra_serf__discover_vcc(const char **vcc_url, 1379 svn_ra_serf__session_t *session, 1380 svn_ra_serf__connection_t *conn, 1381 apr_pool_t *pool); 1382 1383 /* Set @a REPORT_TARGET to the URI of the resource at which generic 1384 * (path-agnostic) REPORTs should be aimed for @a SESSION. Use @a 1385 * CONN for any required network communications if it is non-NULL; 1386 * otherwise use the default connection. 1387 * 1388 * All temporary allocations will be made in @a POOL. 1389 */ 1390 svn_error_t * 1391 svn_ra_serf__report_resource(const char **report_target, 1392 svn_ra_serf__session_t *session, 1393 svn_ra_serf__connection_t *conn, 1394 apr_pool_t *pool); 1395 1396 /* Set @a REL_PATH to a path (not URI-encoded) relative to the root of 1397 * the repository pointed to by @a SESSION, based on original path 1398 * (URI-encoded) @a ORIG_PATH. Use @a CONN for any required network 1399 * communications if it is non-NULL; otherwise use the default 1400 * connection. Use POOL for allocations. */ 1401 svn_error_t * 1402 svn_ra_serf__get_relative_path(const char **rel_path, 1403 const char *orig_path, 1404 svn_ra_serf__session_t *session, 1405 svn_ra_serf__connection_t *conn, 1406 apr_pool_t *pool); 1407 1408 1409 /* Using the default connection in SESSION (conns[0]), get the youngest 1410 revnum from the server, returning it in *YOUNGEST. 1411 1412 This function operates synchronously. 1413 1414 All temporary allocations are performed in SCRATCH_POOL. */ 1415 svn_error_t * 1416 svn_ra_serf__get_youngest_revnum(svn_revnum_t *youngest, 1417 svn_ra_serf__session_t *session, 1418 apr_pool_t *scratch_pool); 1419 1420 1421 /* Generate a revision-stable URL. 1422 1423 The RA APIs all refer to user/public URLs that float along with the 1424 youngest revision. In many cases, we do NOT want to work with that URL 1425 since it can change from one moment to the next. Especially if we 1426 attempt to operation against multiple floating URLs -- we could end up 1427 referring to two separate revisions. 1428 1429 The DAV RA provider(s) solve this by generating a URL that is specific 1430 to a revision by using a URL into a "baseline collection". 1431 1432 For a specified SESSION, with an optional CONN (if NULL, then the 1433 session's default connection will be used; specifically SESSION->conns[0]), 1434 generate a revision-stable URL for URL at REVISION. If REVISION is 1435 SVN_INVALID_REVNUM, then the stable URL will refer to the youngest 1436 revision at the time this function was called. 1437 1438 If URL is NULL, then the session root will be used. 1439 1440 The stable URL will be placed into *STABLE_URL, allocated from RESULT_POOL. 1441 1442 If LATEST_REVNUM is not NULL, then the revision used will be placed into 1443 *LATEST_REVNUM. That will be equal to youngest, or the given REVISION. 1444 1445 This function operates synchronously, if any communication to the server 1446 is required. Communication is needed if REVISION is SVN_INVALID_REVNUM 1447 (to get the current youngest revnum), or if the specified REVISION is not 1448 (yet) in our cache of baseline collections. 1449 1450 All temporary allocations are performed in SCRATCH_POOL. */ 1451 svn_error_t * 1452 svn_ra_serf__get_stable_url(const char **stable_url, 1453 svn_revnum_t *latest_revnum, 1454 svn_ra_serf__session_t *session, 1455 svn_ra_serf__connection_t *conn, 1456 const char *url, 1457 svn_revnum_t revision, 1458 apr_pool_t *result_pool, 1459 apr_pool_t *scratch_pool); 1460 1461 1462 /** RA functions **/ 1463 1464 /* Implements svn_ra__vtable_t.get_log(). */ 1465 svn_error_t * 1466 svn_ra_serf__get_log(svn_ra_session_t *session, 1467 const apr_array_header_t *paths, 1468 svn_revnum_t start, 1469 svn_revnum_t end, 1470 int limit, 1471 svn_boolean_t discover_changed_paths, 1472 svn_boolean_t strict_node_history, 1473 svn_boolean_t include_merged_revisions, 1474 const apr_array_header_t *revprops, 1475 svn_log_entry_receiver_t receiver, 1476 void *receiver_baton, 1477 apr_pool_t *pool); 1478 1479 /* Implements svn_ra__vtable_t.get_locations(). */ 1480 svn_error_t * 1481 svn_ra_serf__get_locations(svn_ra_session_t *session, 1482 apr_hash_t **locations, 1483 const char *path, 1484 svn_revnum_t peg_revision, 1485 const apr_array_header_t *location_revisions, 1486 apr_pool_t *pool); 1487 1488 /* Implements svn_ra__vtable_t.get_location_segments(). */ 1489 svn_error_t * 1490 svn_ra_serf__get_location_segments(svn_ra_session_t *session, 1491 const char *path, 1492 svn_revnum_t peg_revision, 1493 svn_revnum_t start_rev, 1494 svn_revnum_t end_rev, 1495 svn_location_segment_receiver_t receiver, 1496 void *receiver_baton, 1497 apr_pool_t *pool); 1498 1499 /* Implements svn_ra__vtable_t.do_diff(). */ 1500 svn_error_t * 1501 svn_ra_serf__do_diff(svn_ra_session_t *session, 1502 const svn_ra_reporter3_t **reporter, 1503 void **report_baton, 1504 svn_revnum_t revision, 1505 const char *diff_target, 1506 svn_depth_t depth, 1507 svn_boolean_t ignore_ancestry, 1508 svn_boolean_t text_deltas, 1509 const char *versus_url, 1510 const svn_delta_editor_t *diff_editor, 1511 void *diff_baton, 1512 apr_pool_t *pool); 1513 1514 /* Implements svn_ra__vtable_t.do_status(). */ 1515 svn_error_t * 1516 svn_ra_serf__do_status(svn_ra_session_t *ra_session, 1517 const svn_ra_reporter3_t **reporter, 1518 void **report_baton, 1519 const char *status_target, 1520 svn_revnum_t revision, 1521 svn_depth_t depth, 1522 const svn_delta_editor_t *status_editor, 1523 void *status_baton, 1524 apr_pool_t *pool); 1525 1526 /* Implements svn_ra__vtable_t.do_update(). */ 1527 svn_error_t * 1528 svn_ra_serf__do_update(svn_ra_session_t *ra_session, 1529 const svn_ra_reporter3_t **reporter, 1530 void **report_baton, 1531 svn_revnum_t revision_to_update_to, 1532 const char *update_target, 1533 svn_depth_t depth, 1534 svn_boolean_t send_copyfrom_args, 1535 svn_boolean_t ignore_ancestry, 1536 const svn_delta_editor_t *update_editor, 1537 void *update_baton, 1538 apr_pool_t *result_pool, 1539 apr_pool_t *scratch_pool); 1540 1541 /* Implements svn_ra__vtable_t.do_switch(). */ 1542 svn_error_t * 1543 svn_ra_serf__do_switch(svn_ra_session_t *ra_session, 1544 const svn_ra_reporter3_t **reporter, 1545 void **report_baton, 1546 svn_revnum_t revision_to_switch_to, 1547 const char *switch_target, 1548 svn_depth_t depth, 1549 const char *switch_url, 1550 svn_boolean_t send_copyfrom_args, 1551 svn_boolean_t ignore_ancestry, 1552 const svn_delta_editor_t *switch_editor, 1553 void *switch_baton, 1554 apr_pool_t *result_pool, 1555 apr_pool_t *scratch_pool); 1556 1557 /* Implements svn_ra__vtable_t.get_file_revs(). */ 1558 svn_error_t * 1559 svn_ra_serf__get_file_revs(svn_ra_session_t *session, 1560 const char *path, 1561 svn_revnum_t start, 1562 svn_revnum_t end, 1563 svn_boolean_t include_merged_revisions, 1564 svn_file_rev_handler_t handler, 1565 void *handler_baton, 1566 apr_pool_t *pool); 1567 1568 /* Implements svn_ra__vtable_t.get_dated_revision(). */ 1569 svn_error_t * 1570 svn_ra_serf__get_dated_revision(svn_ra_session_t *session, 1571 svn_revnum_t *revision, 1572 apr_time_t tm, 1573 apr_pool_t *pool); 1574 1575 /* Implements svn_ra__vtable_t.get_commit_editor(). */ 1576 svn_error_t * 1577 svn_ra_serf__get_commit_editor(svn_ra_session_t *session, 1578 const svn_delta_editor_t **editor, 1579 void **edit_baton, 1580 apr_hash_t *revprop_table, 1581 svn_commit_callback2_t callback, 1582 void *callback_baton, 1583 apr_hash_t *lock_tokens, 1584 svn_boolean_t keep_locks, 1585 apr_pool_t *pool); 1586 1587 /* Implements svn_ra__vtable_t.get_file(). */ 1588 svn_error_t * 1589 svn_ra_serf__get_file(svn_ra_session_t *session, 1590 const char *path, 1591 svn_revnum_t revision, 1592 svn_stream_t *stream, 1593 svn_revnum_t *fetched_rev, 1594 apr_hash_t **props, 1595 apr_pool_t *pool); 1596 1597 /* Implements svn_ra__vtable_t.change_rev_prop(). */ 1598 svn_error_t * 1599 svn_ra_serf__change_rev_prop(svn_ra_session_t *session, 1600 svn_revnum_t rev, 1601 const char *name, 1602 const svn_string_t *const *old_value_p, 1603 const svn_string_t *value, 1604 apr_pool_t *pool); 1605 1606 /* Implements svn_ra__vtable_t.replay(). */ 1607 svn_error_t * 1608 svn_ra_serf__replay(svn_ra_session_t *ra_session, 1609 svn_revnum_t revision, 1610 svn_revnum_t low_water_mark, 1611 svn_boolean_t text_deltas, 1612 const svn_delta_editor_t *editor, 1613 void *edit_baton, 1614 apr_pool_t *pool); 1615 1616 /* Implements svn_ra__vtable_t.replay_range(). */ 1617 svn_error_t * 1618 svn_ra_serf__replay_range(svn_ra_session_t *ra_session, 1619 svn_revnum_t start_revision, 1620 svn_revnum_t end_revision, 1621 svn_revnum_t low_water_mark, 1622 svn_boolean_t send_deltas, 1623 svn_ra_replay_revstart_callback_t revstart_func, 1624 svn_ra_replay_revfinish_callback_t revfinish_func, 1625 void *replay_baton, 1626 apr_pool_t *pool); 1627 1628 /* Implements svn_ra__vtable_t.lock(). */ 1629 svn_error_t * 1630 svn_ra_serf__lock(svn_ra_session_t *ra_session, 1631 apr_hash_t *path_revs, 1632 const char *comment, 1633 svn_boolean_t force, 1634 svn_ra_lock_callback_t lock_func, 1635 void *lock_baton, 1636 apr_pool_t *pool); 1637 1638 /* Implements svn_ra__vtable_t.unlock(). */ 1639 svn_error_t * 1640 svn_ra_serf__unlock(svn_ra_session_t *ra_session, 1641 apr_hash_t *path_tokens, 1642 svn_boolean_t force, 1643 svn_ra_lock_callback_t lock_func, 1644 void *lock_baton, 1645 apr_pool_t *pool); 1646 1647 /* Implements svn_ra__vtable_t.get_lock(). */ 1648 svn_error_t * 1649 svn_ra_serf__get_lock(svn_ra_session_t *ra_session, 1650 svn_lock_t **lock, 1651 const char *path, 1652 apr_pool_t *pool); 1653 1654 /* Implements svn_ra__vtable_t.get_locks(). */ 1655 svn_error_t * 1656 svn_ra_serf__get_locks(svn_ra_session_t *ra_session, 1657 apr_hash_t **locks, 1658 const char *path, 1659 svn_depth_t depth, 1660 apr_pool_t *pool); 1661 1662 /* Request a mergeinfo-report from the URL attached to SESSION, 1663 and fill in the MERGEINFO hash with the results. 1664 1665 Implements svn_ra__vtable_t.get_mergeinfo(). 1666 */ 1667 svn_error_t * 1668 svn_ra_serf__get_mergeinfo(svn_ra_session_t *ra_session, 1669 apr_hash_t **mergeinfo, 1670 const apr_array_header_t *paths, 1671 svn_revnum_t revision, 1672 svn_mergeinfo_inheritance_t inherit, 1673 svn_boolean_t include_descendants, 1674 apr_pool_t *pool); 1675 1676 /* Exchange capabilities with the server, by sending an OPTIONS 1677 * request announcing the client's capabilities, and by filling 1678 * SERF_SESS->capabilities with the server's capabilities as read from 1679 * the response headers. Use POOL only for temporary allocation. 1680 * 1681 * If the CORRECTED_URL is non-NULL, allow the OPTIONS response to 1682 * report a server-dictated redirect or relocation (HTTP 301 or 302 1683 * error codes), setting *CORRECTED_URL to the value of the corrected 1684 * repository URL. Otherwise, such responses from the server will 1685 * generate an error. (In either case, no capabilities are exchanged 1686 * if there is, in fact, such a response from the server.) 1687 */ 1688 svn_error_t * 1689 svn_ra_serf__exchange_capabilities(svn_ra_serf__session_t *serf_sess, 1690 const char **corrected_url, 1691 apr_pool_t *pool); 1692 1693 /* Implements svn_ra__vtable_t.has_capability(). */ 1694 svn_error_t * 1695 svn_ra_serf__has_capability(svn_ra_session_t *ra_session, 1696 svn_boolean_t *has, 1697 const char *capability, 1698 apr_pool_t *pool); 1699 1700 /* Implements svn_ra__vtable_t.get_deleted_rev(). */ 1701 svn_error_t * 1702 svn_ra_serf__get_deleted_rev(svn_ra_session_t *session, 1703 const char *path, 1704 svn_revnum_t peg_revision, 1705 svn_revnum_t end_revision, 1706 svn_revnum_t *revision_deleted, 1707 apr_pool_t *pool); 1708 1709 /* Implements the get_inherited_props RA layer function. */ 1710 svn_error_t * svn_ra_serf__get_inherited_props(svn_ra_session_t *session, 1711 apr_array_header_t **iprops, 1712 const char *path, 1713 svn_revnum_t revision, 1714 apr_pool_t *result_pool, 1715 apr_pool_t *scratch_pool); 1716 1717 /* Implements svn_ra__vtable_t.get_repos_root(). */ 1718 svn_error_t * 1719 svn_ra_serf__get_repos_root(svn_ra_session_t *ra_session, 1720 const char **url, 1721 apr_pool_t *pool); 1722 1723 /* Implements svn_ra__vtable_t.register_editor_shim_callbacks(). */ 1724 svn_error_t * 1725 svn_ra_serf__register_editor_shim_callbacks(svn_ra_session_t *session, 1726 svn_delta_shim_callbacks_t *callbacks); 1727 1728 /*** Authentication handler declarations ***/ 1729 1730 /** 1731 * Callback function that loads the credentials for Basic and Digest 1732 * authentications, both for server and proxy authentication. 1733 */ 1734 apr_status_t 1735 svn_ra_serf__credentials_callback(char **username, char **password, 1736 serf_request_t *request, void *baton, 1737 int code, const char *authn_type, 1738 const char *realm, 1739 apr_pool_t *pool); 1740 1741 1742 /*** General utility functions ***/ 1743 1744 /** 1745 * Convert an HTTP STATUS_CODE resulting from a WebDAV request against 1746 * PATH to the relevant error code. Use the response-supplied LOCATION 1747 * where it necessary. 1748 */ 1749 svn_error_t * 1750 svn_ra_serf__error_on_status(serf_status_line sline, 1751 const char *path, 1752 const char *location); 1753 1754 /* ###? */ 1755 svn_error_t * 1756 svn_ra_serf__copy_into_spillbuf(svn_spillbuf_t **spillbuf, 1757 serf_bucket_t *bkt, 1758 apr_pool_t *result_pool, 1759 apr_pool_t *scratch_pool); 1760 1761 /* ###? */ 1762 serf_bucket_t * 1763 svn_ra_serf__create_sb_bucket(svn_spillbuf_t *spillbuf, 1764 serf_bucket_alloc_t *allocator, 1765 apr_pool_t *result_pool, 1766 apr_pool_t *scratch_pool); 1767 1768 /** Wrap STATUS from an serf function. If STATUS is not serf error code, 1769 * this is equivalent to svn_error_wrap_apr(). 1770 */ 1771 svn_error_t * 1772 svn_ra_serf__wrap_err(apr_status_t status, 1773 const char *fmt, 1774 ...); 1775 1776 1777 #if defined(SVN_DEBUG) 1778 /* Wrapper macros to collect file and line information */ 1779 #define svn_ra_serf__wrap_err \ 1780 (svn_error__locate(__FILE__,__LINE__), (svn_ra_serf__wrap_err)) 1781 1782 #endif 1783 1784 #ifdef __cplusplus 1785 } 1786 #endif /* __cplusplus */ 1787 1788 #endif /* SVN_LIBSVN_RA_SERF_RA_SERF_H */ 1789