/* * log.c : entry point for log RA functions for ra_serf * * ==================================================================== * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * ==================================================================== */ #include #include #include "svn_hash.h" #include "svn_pools.h" #include "svn_ra.h" #include "svn_dav.h" #include "svn_base64.h" #include "svn_xml.h" #include "svn_config.h" #include "svn_path.h" #include "svn_props.h" #include "private/svn_dav_protocol.h" #include "private/svn_string_private.h" #include "private/svn_subr_private.h" #include "svn_private_config.h" #include "ra_serf.h" #include "../libsvn_ra/ra_loader.h" /* * This enum represents the current state of our XML parsing for a REPORT. */ enum log_state_e { INITIAL = XML_STATE_INITIAL, REPORT, ITEM, VERSION, CREATOR, DATE, COMMENT, REVPROP, HAS_CHILDREN, ADDED_PATH, REPLACED_PATH, DELETED_PATH, MODIFIED_PATH, SUBTRACTIVE_MERGE }; typedef struct log_context_t { apr_pool_t *pool; /* parameters set by our caller */ const apr_array_header_t *paths; svn_revnum_t start; svn_revnum_t end; int limit; svn_boolean_t changed_paths; svn_boolean_t strict_node_history; svn_boolean_t include_merged_revisions; const apr_array_header_t *revprops; int nest_level; /* used to track mergeinfo nesting levels */ int count; /* only incremented when nest_level == 0 */ /* Collect information for storage into a log entry. Most of the entry members are collected by individual states. revprops and paths are N datapoints per entry. */ apr_hash_t *collect_revprops; apr_hash_t *collect_paths; /* log receiver function and baton */ svn_log_entry_receiver_t receiver; void *receiver_baton; /* pre-1.5 compatibility */ svn_boolean_t want_author; svn_boolean_t want_date; svn_boolean_t want_message; } log_context_t; #define D_ "DAV:" #define S_ SVN_XML_NAMESPACE static const svn_ra_serf__xml_transition_t log_ttable[] = { { INITIAL, S_, "log-report", REPORT, FALSE, { NULL }, FALSE }, /* Note that we have an opener here. We need to construct a new LOG_ENTRY to record multiple paths. */ { REPORT, S_, "log-item", ITEM, FALSE, { NULL }, TRUE }, { ITEM, D_, SVN_DAV__VERSION_NAME, VERSION, TRUE, { NULL }, TRUE }, { ITEM, D_, "creator-displayname", CREATOR, TRUE, { "?encoding", NULL }, TRUE }, { ITEM, S_, "date", DATE, TRUE, { "?encoding", NULL }, TRUE }, { ITEM, D_, "comment", COMMENT, TRUE, { "?encoding", NULL }, TRUE }, { ITEM, S_, "revprop", REVPROP, TRUE, { "name", "?encoding", NULL }, TRUE }, { ITEM, S_, "has-children", HAS_CHILDREN, FALSE, { NULL }, TRUE }, { ITEM, S_, "subtractive-merge", SUBTRACTIVE_MERGE, FALSE, { NULL }, TRUE }, { ITEM, S_, "added-path", ADDED_PATH, TRUE, { "?node-kind", "?text-mods", "?prop-mods", "?copyfrom-path", "?copyfrom-rev", NULL }, TRUE }, { ITEM, S_, "replaced-path", REPLACED_PATH, TRUE, { "?node-kind", "?text-mods", "?prop-mods", "?copyfrom-path", "?copyfrom-rev", NULL }, TRUE }, { ITEM, S_, "deleted-path", DELETED_PATH, TRUE, { "?node-kind", "?text-mods", "?prop-mods", NULL }, TRUE }, { ITEM, S_, "modified-path", MODIFIED_PATH, TRUE, { "?node-kind", "?text-mods", "?prop-mods", NULL }, TRUE }, { 0 } }; /* Store CDATA into REVPROPS, associated with PROPNAME. If ENCODING is not NULL, then it must base "base64" and CDATA will be decoded first. NOTE: PROPNAME must live longer than REVPROPS. */ static svn_error_t * collect_revprop(apr_hash_t *revprops, const char *propname, const svn_string_t *cdata, const char *encoding) { apr_pool_t *result_pool = apr_hash_pool_get(revprops); const svn_string_t *decoded; if (encoding) { /* Check for a known encoding type. This is easy -- there's only one. */ if (strcmp(encoding, "base64") != 0) { return svn_error_createf(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL, _("Unsupported encoding '%s'"), encoding); } decoded = svn_base64_decode_string(cdata, result_pool); } else { decoded = svn_string_dup(cdata, result_pool); } /* Caller has ensured PROPNAME has sufficient lifetime. */ svn_hash_sets(revprops, propname, decoded); return SVN_NO_ERROR; } /* Record ACTION on the path in CDATA into PATHS. Other properties about the action are pulled from ATTRS. */ static svn_error_t * collect_path(apr_hash_t *paths, char action, const svn_string_t *cdata, apr_hash_t *attrs) { apr_pool_t *result_pool = apr_hash_pool_get(paths); svn_log_changed_path2_t *lcp; const char *copyfrom_path; const char *copyfrom_rev; const char *path; lcp = svn_log_changed_path2_create(result_pool); lcp->action = action; lcp->copyfrom_rev = SVN_INVALID_REVNUM; /* COPYFROM_* are only recorded for ADDED_PATH and REPLACED_PATH. */ copyfrom_path = svn_hash_gets(attrs, "copyfrom-path"); copyfrom_rev = svn_hash_gets(attrs, "copyfrom-rev"); if (copyfrom_path && copyfrom_rev) { apr_int64_t rev; SVN_ERR(svn_cstring_atoi64(&rev, copyfrom_rev)); if (SVN_IS_VALID_REVNUM((svn_revnum_t)rev)) { lcp->copyfrom_path = apr_pstrdup(result_pool, copyfrom_path); lcp->copyfrom_rev = (svn_revnum_t)rev; } } lcp->node_kind = svn_node_kind_from_word(svn_hash_gets(attrs, "node-kind")); lcp->text_modified = svn_tristate__from_word(svn_hash_gets(attrs, "text-mods")); lcp->props_modified = svn_tristate__from_word(svn_hash_gets(attrs, "prop-mods")); path = apr_pstrmemdup(result_pool, cdata->data, cdata->len); svn_hash_sets(paths, path, lcp); return SVN_NO_ERROR; } /* Conforms to svn_ra_serf__xml_opened_t */ static svn_error_t * log_opened(svn_ra_serf__xml_estate_t *xes, void *baton, int entered_state, const svn_ra_serf__dav_props_t *tag, apr_pool_t *scratch_pool) { log_context_t *log_ctx = baton; if (entered_state == ITEM) { apr_pool_t *state_pool = svn_ra_serf__xml_state_pool(xes); log_ctx->collect_revprops = apr_hash_make(state_pool); log_ctx->collect_paths = apr_hash_make(state_pool); } return SVN_NO_ERROR; } /* Conforms to svn_ra_serf__xml_closed_t */ static svn_error_t * log_closed(svn_ra_serf__xml_estate_t *xes, void *baton, int leaving_state, const svn_string_t *cdata, apr_hash_t *attrs, apr_pool_t *scratch_pool) { log_context_t *log_ctx = baton; if (leaving_state == ITEM) { svn_log_entry_t *log_entry; const char *rev_str; if ((log_ctx->limit > 0) && (log_ctx->nest_level == 0) && (++log_ctx->count > log_ctx->limit)) { return SVN_NO_ERROR; } log_entry = svn_log_entry_create(scratch_pool); /* Pick up the paths from the context. These have the same lifetime as this state. That is long enough for us to pass the paths to the receiver callback. */ if (apr_hash_count(log_ctx->collect_paths) > 0) { log_entry->changed_paths = log_ctx->collect_paths; log_entry->changed_paths2 = log_ctx->collect_paths; } /* ... and same story for the collected revprops. */ log_entry->revprops = log_ctx->collect_revprops; log_entry->has_children = svn_hash__get_bool(attrs, "has-children", FALSE); log_entry->subtractive_merge = svn_hash__get_bool(attrs, "subtractive-merge", FALSE); rev_str = svn_hash_gets(attrs, "revision"); if (rev_str) { apr_int64_t rev; SVN_ERR(svn_cstring_atoi64(&rev, rev_str)); log_entry->revision = (svn_revnum_t)rev; } else log_entry->revision = SVN_INVALID_REVNUM; /* Give the info to the reporter */ SVN_ERR(log_ctx->receiver(log_ctx->receiver_baton, log_entry, scratch_pool)); if (log_entry->has_children) { log_ctx->nest_level++; } if (! SVN_IS_VALID_REVNUM(log_entry->revision)) { SVN_ERR_ASSERT(log_ctx->nest_level); log_ctx->nest_level--; } /* These hash tables are going to be unusable once this state's pool is destroyed. But let's not leave stale pointers in structures that have a longer life. */ log_ctx->collect_revprops = NULL; log_ctx->collect_paths = NULL; } else if (leaving_state == VERSION) { svn_ra_serf__xml_note(xes, ITEM, "revision", cdata->data); } else if (leaving_state == CREATOR) { if (log_ctx->want_author) { SVN_ERR(collect_revprop(log_ctx->collect_revprops, SVN_PROP_REVISION_AUTHOR, cdata, svn_hash_gets(attrs, "encoding"))); } } else if (leaving_state == DATE) { if (log_ctx->want_date) { SVN_ERR(collect_revprop(log_ctx->collect_revprops, SVN_PROP_REVISION_DATE, cdata, svn_hash_gets(attrs, "encoding"))); } } else if (leaving_state == COMMENT) { if (log_ctx->want_message) { SVN_ERR(collect_revprop(log_ctx->collect_revprops, SVN_PROP_REVISION_LOG, cdata, svn_hash_gets(attrs, "encoding"))); } } else if (leaving_state == REVPROP) { apr_pool_t *result_pool = apr_hash_pool_get(log_ctx->collect_revprops); SVN_ERR(collect_revprop( log_ctx->collect_revprops, apr_pstrdup(result_pool, svn_hash_gets(attrs, "name")), cdata, svn_hash_gets(attrs, "encoding") )); } else if (leaving_state == HAS_CHILDREN) { svn_ra_serf__xml_note(xes, ITEM, "has-children", "yes"); } else if (leaving_state == SUBTRACTIVE_MERGE) { svn_ra_serf__xml_note(xes, ITEM, "subtractive-merge", "yes"); } else { char action; if (leaving_state == ADDED_PATH) action = 'A'; else if (leaving_state == REPLACED_PATH) action = 'R'; else if (leaving_state == DELETED_PATH) action = 'D'; else { SVN_ERR_ASSERT(leaving_state == MODIFIED_PATH); action = 'M'; } SVN_ERR(collect_path(log_ctx->collect_paths, action, cdata, attrs)); } return SVN_NO_ERROR; } /* Implements svn_ra_serf__request_body_delegate_t */ static svn_error_t * create_log_body(serf_bucket_t **body_bkt, void *baton, serf_bucket_alloc_t *alloc, apr_pool_t *pool /* request pool */, apr_pool_t *scratch_pool) { serf_bucket_t *buckets; log_context_t *log_ctx = baton; buckets = serf_bucket_aggregate_create(alloc); svn_ra_serf__add_open_tag_buckets(buckets, alloc, "S:log-report", "xmlns:S", SVN_XML_NAMESPACE, SVN_VA_NULL); svn_ra_serf__add_tag_buckets(buckets, "S:start-revision", apr_ltoa(pool, log_ctx->start), alloc); svn_ra_serf__add_tag_buckets(buckets, "S:end-revision", apr_ltoa(pool, log_ctx->end), alloc); if (log_ctx->limit) { svn_ra_serf__add_tag_buckets(buckets, "S:limit", apr_ltoa(pool, log_ctx->limit), alloc); } if (log_ctx->changed_paths) { svn_ra_serf__add_empty_tag_buckets(buckets, alloc, "S:discover-changed-paths", SVN_VA_NULL); } if (log_ctx->strict_node_history) { svn_ra_serf__add_empty_tag_buckets(buckets, alloc, "S:strict-node-history", SVN_VA_NULL); } if (log_ctx->include_merged_revisions) { svn_ra_serf__add_empty_tag_buckets(buckets, alloc, "S:include-merged-revisions", SVN_VA_NULL); } if (log_ctx->revprops) { int i; for (i = 0; i < log_ctx->revprops->nelts; i++) { char *name = APR_ARRAY_IDX(log_ctx->revprops, i, char *); svn_ra_serf__add_tag_buckets(buckets, "S:revprop", name, alloc); } if (log_ctx->revprops->nelts == 0) { svn_ra_serf__add_empty_tag_buckets(buckets, alloc, "S:no-revprops", SVN_VA_NULL); } } else { svn_ra_serf__add_empty_tag_buckets(buckets, alloc, "S:all-revprops", SVN_VA_NULL); } if (log_ctx->paths) { int i; for (i = 0; i < log_ctx->paths->nelts; i++) { svn_ra_serf__add_tag_buckets(buckets, "S:path", APR_ARRAY_IDX(log_ctx->paths, i, const char*), alloc); } } svn_ra_serf__add_empty_tag_buckets(buckets, alloc, "S:encode-binary-props", SVN_VA_NULL); svn_ra_serf__add_close_tag_buckets(buckets, alloc, "S:log-report"); *body_bkt = buckets; return SVN_NO_ERROR; } svn_error_t * svn_ra_serf__get_log(svn_ra_session_t *ra_session, const apr_array_header_t *paths, svn_revnum_t start, svn_revnum_t end, int limit, svn_boolean_t discover_changed_paths, svn_boolean_t strict_node_history, svn_boolean_t include_merged_revisions, const apr_array_header_t *revprops, svn_log_entry_receiver_t receiver, void *receiver_baton, apr_pool_t *pool) { log_context_t *log_ctx; svn_ra_serf__session_t *session = ra_session->priv; svn_ra_serf__handler_t *handler; svn_ra_serf__xml_context_t *xmlctx; svn_boolean_t want_custom_revprops; svn_revnum_t peg_rev; const char *req_url; log_ctx = apr_pcalloc(pool, sizeof(*log_ctx)); log_ctx->pool = pool; log_ctx->receiver = receiver; log_ctx->receiver_baton = receiver_baton; log_ctx->paths = paths; log_ctx->start = start; log_ctx->end = end; log_ctx->limit = limit; log_ctx->changed_paths = discover_changed_paths; log_ctx->strict_node_history = strict_node_history; log_ctx->include_merged_revisions = include_merged_revisions; log_ctx->revprops = revprops; log_ctx->nest_level = 0; want_custom_revprops = FALSE; if (revprops) { int i; for (i = 0; i < revprops->nelts; i++) { char *name = APR_ARRAY_IDX(revprops, i, char *); if (strcmp(name, SVN_PROP_REVISION_AUTHOR) == 0) log_ctx->want_author = TRUE; else if (strcmp(name, SVN_PROP_REVISION_DATE) == 0) log_ctx->want_date = TRUE; else if (strcmp(name, SVN_PROP_REVISION_LOG) == 0) log_ctx->want_message = TRUE; else want_custom_revprops = TRUE; } } else { log_ctx->want_author = log_ctx->want_date = log_ctx->want_message = TRUE; want_custom_revprops = TRUE; } if (want_custom_revprops) { svn_boolean_t has_log_revprops; SVN_ERR(svn_ra_serf__has_capability(ra_session, &has_log_revprops, SVN_RA_CAPABILITY_LOG_REVPROPS, pool)); if (!has_log_revprops) return svn_error_create(SVN_ERR_RA_NOT_IMPLEMENTED, NULL, _("Server does not support custom revprops" " via log")); } /* At this point, we may have a deleted file. So, we'll match ra_neon's * behavior and use the larger of start or end as our 'peg' rev. */ peg_rev = (start == SVN_INVALID_REVNUM || start > end) ? start : end; SVN_ERR(svn_ra_serf__get_stable_url(&req_url, NULL /* latest_revnum */, session, NULL /* url */, peg_rev, pool, pool)); xmlctx = svn_ra_serf__xml_context_create(log_ttable, log_opened, log_closed, NULL, log_ctx, pool); handler = svn_ra_serf__create_expat_handler(session, xmlctx, NULL, pool); handler->method = "REPORT"; handler->path = req_url; handler->body_delegate = create_log_body; handler->body_delegate_baton = log_ctx; handler->body_type = "text/xml"; SVN_ERR(svn_ra_serf__context_run_one(handler, pool)); if (handler->sline.code != 200) SVN_ERR(svn_ra_serf__unexpected_status(handler)); return SVN_NO_ERROR; }