| /* |
| * log.c : routines for requesting and parsing log reports |
| * |
| * ==================================================================== |
| * Copyright (c) 2000-2002 CollabNet. All rights reserved. |
| * |
| * This software is licensed as described in the file COPYING, which |
| * you should have received as part of this distribution. The terms |
| * are also available at http://subversion.tigris.org/license-1.html. |
| * If newer versions of this license are posted there, you may use a |
| * newer version instead, at your option. |
| * |
| * This software consists of voluntary contributions made by many |
| * individuals. For exact contribution history, see the revision |
| * history and logs, available at http://subversion.tigris.org/. |
| * ==================================================================== |
| */ |
| |
| |
| |
| #define APR_WANT_STRFUNC |
| #include <apr_want.h> /* for strcmp() */ |
| |
| #include <apr_pools.h> |
| #include <apr_tables.h> |
| #include <apr_strings.h> |
| #include <apr_portable.h> |
| |
| #include <ne_basic.h> |
| #include <ne_utils.h> |
| #include <ne_basic.h> |
| #include <ne_207.h> |
| #include <ne_props.h> |
| #include <ne_xml.h> |
| |
| #include "svn_error.h" |
| #include "svn_pools.h" |
| #include "svn_delta.h" |
| #include "svn_io.h" |
| #include "svn_ra.h" |
| #include "svn_path.h" |
| #include "svn_xml.h" |
| |
| #include "ra_dav.h" |
| |
| |
| |
| /*** Code ***/ |
| |
| /* Userdata for the Neon XML element callbacks. */ |
| struct log_baton |
| { |
| /* Allocate log message information. |
| * NOTE: this pool may be cleared multiple times as log messages are |
| * received. |
| */ |
| apr_pool_t *subpool; |
| |
| /* Information about each log item in turn. */ |
| svn_revnum_t revision; |
| const char *author; |
| const char *date; |
| const char *msg; |
| |
| /* Keys are the paths changed in this commit, allocated in SUBPOOL; |
| the table itself is also allocated in SUBPOOL. If this table is |
| NULL, no changed paths were indicated -- which doesn't mean no |
| paths were changed, just means that this log invocation didn't |
| ask for them to be reported. */ |
| apr_hash_t *changed_paths; |
| |
| /* Client's callback, invoked on the above fields when the end of an |
| item is seen. */ |
| svn_log_message_receiver_t receiver; |
| void *receiver_baton; |
| |
| /* If `receiver' returns error, it is stored here. */ |
| svn_error_t *err; |
| }; |
| |
| |
| /* Prepare LB to start accumulating the next log item, by wiping all |
| * information related to the previous item and clearing the pool in |
| * which they were allocated. Do not touch any stored error, however. |
| */ |
| static void |
| reset_log_item (struct log_baton *lb) |
| { |
| lb->revision = SVN_INVALID_REVNUM; |
| lb->author = NULL; |
| lb->date = NULL; |
| lb->msg = NULL; |
| lb->changed_paths = NULL; |
| |
| svn_pool_clear (lb->subpool); |
| } |
| |
| |
| /* |
| * This implements the `ne_xml_validate_cb' prototype. |
| */ |
| static int |
| log_validate(void *userdata, ne_xml_elmid parent, ne_xml_elmid child) |
| { |
| /* ### todo */ |
| return NE_XML_VALID; |
| } |
| |
| |
| /* |
| * This implements the `ne_xml_startelm_cb' prototype. |
| */ |
| static int |
| log_start_element(void *userdata, |
| const struct ne_xml_elm *elm, |
| const char **atts) |
| { |
| /* ### todo */ |
| return NE_XML_VALID; |
| } |
| |
| |
| /* |
| * This implements the `ne_xml_endelm_cb' prototype. |
| */ |
| static int |
| log_end_element(void *userdata, |
| const struct ne_xml_elm *elm, |
| const char *cdata) |
| { |
| struct log_baton *lb = userdata; |
| |
| switch (elm->id) |
| { |
| case ELEM_version_name: |
| lb->revision = SVN_STR_TO_REV (cdata); |
| break; |
| case ELEM_creator_displayname: |
| lb->author = apr_pstrdup (lb->subpool, cdata); |
| break; |
| case ELEM_log_date: |
| lb->date = apr_pstrdup (lb->subpool, cdata); |
| break; |
| case ELEM_added_path: |
| case ELEM_deleted_path: |
| case ELEM_changed_path: |
| { |
| char *path = apr_pstrdup (lb->subpool, cdata); |
| char action; |
| |
| /* See documentation for `svn_repos_node_t' in svn_repos.h, |
| and `svn_log_message_receiver_t' in svn_types.h, for more |
| about these action codes. */ |
| if (elm->id == ELEM_added_path) |
| action = 'A'; |
| else if (elm->id == ELEM_deleted_path) |
| action = 'D'; |
| else |
| action = 'U'; |
| |
| if (lb->changed_paths == NULL) |
| lb->changed_paths = apr_hash_make(lb->subpool); |
| |
| apr_hash_set(lb->changed_paths, path, APR_HASH_KEY_STRING, |
| (void *) ((int) action)); |
| } |
| break; |
| case ELEM_comment: |
| lb->msg = apr_pstrdup (lb->subpool, cdata); |
| break; |
| case ELEM_log_item: |
| { |
| /* ### Naive call for now. We still need to arrange things so |
| that last_call gets passed properly, which will |
| be... interesting. Well, not so bad, just need to put an |
| attribute on the end element of the last item. This is a |
| change to mod_dav_svn too. */ |
| |
| svn_error_t *err = (*(lb->receiver))(lb->receiver_baton, |
| lb->changed_paths, |
| lb->revision, |
| lb->author, |
| lb->date, |
| lb->msg); |
| |
| reset_log_item (lb); |
| |
| if (err) |
| { |
| lb->err = err; /* ### Wrap an existing error, if any? */ |
| return NE_XML_INVALID; /* ### Any other way to express an err? */ |
| } |
| } |
| break; |
| case ELEM_log_report: |
| { |
| /* ### todo: what to do here? We're (hopefully) going to handle |
| the whole last_call thing another way, so maybe the end of |
| the report means nothing... */ |
| |
| /* Yo -- we're going to take Greg's suggestion of treating |
| log_receivers the way we treat delta windows -- last call |
| is indicated by a special call with NULL (or, in this case, |
| SVN_INVALID_REVNUM), instead of combining the last_call |
| indicator with the previous, contentful call. */ |
| } |
| break; |
| } |
| |
| return NE_XML_VALID; |
| } |
| |
| |
| svn_error_t * svn_ra_dav__get_log(void *session_baton, |
| const apr_array_header_t *paths, |
| svn_revnum_t start, |
| svn_revnum_t end, |
| svn_boolean_t discover_changed_paths, |
| svn_log_message_receiver_t receiver, |
| void *receiver_baton) |
| { |
| /* The Plan: Send a request to the server for a log report. |
| * Somewhere in mod_dav_svn, there will be an implementation, R, of |
| * the `svn_log_message_receiver_t' function type. Some other |
| * function in mod_dav_svn will use svn_repos_get_logs() to loop R |
| * over the log messages, and the successive invocations of R will |
| * collectively transmit the report back here, where we parse the |
| * report and invoke RECEIVER (which is an entirely separate |
| * instance of `svn_log_message_receiver_t') on each individual |
| * message in that report. |
| */ |
| |
| int i; |
| svn_ra_session_t *ras = session_baton; |
| svn_stringbuf_t *request_body = svn_stringbuf_create("", ras->pool); |
| struct log_baton lb; |
| |
| /* ### todo: I don't understand why the static, file-global |
| variables shared by update and status are called `report_head' |
| and `report_tail', instead of `request_head' and `request_tail'. |
| Maybe Greg can explain? Meanwhile, I'm tentatively using |
| "request_*" for my local vars below. */ |
| |
| static const char log_request_head[] |
| = "<S:log-report xmlns:S=\"" SVN_XML_NAMESPACE "\">" DEBUG_CR; |
| |
| static const char log_request_tail[] = "</S:log-report>" DEBUG_CR; |
| |
| static const struct ne_xml_elm log_report_elements[] = |
| { |
| { SVN_XML_NAMESPACE, "log-report", ELEM_log_report, 0 }, |
| { SVN_XML_NAMESPACE, "log-item", ELEM_log_item, 0 }, |
| { SVN_XML_NAMESPACE, "date", ELEM_log_date, NE_XML_CDATA }, |
| { SVN_XML_NAMESPACE, "added-path", ELEM_added_path, NE_XML_CDATA }, |
| { SVN_XML_NAMESPACE, "deleted-path", ELEM_deleted_path, NE_XML_CDATA }, |
| { SVN_XML_NAMESPACE, "changed-path", ELEM_changed_path, NE_XML_CDATA }, |
| { "DAV:", "version-name", ELEM_version_name, NE_XML_CDATA }, |
| { "DAV:", "creator-displayname", ELEM_creator_displayname, |
| NE_XML_CDATA }, |
| { "DAV:", "comment", ELEM_comment, NE_XML_CDATA }, |
| { NULL } |
| }; |
| |
| |
| /* Construct the request body. */ |
| svn_stringbuf_appendcstr(request_body, log_request_head); |
| svn_stringbuf_appendcstr(request_body, |
| apr_psprintf(ras->pool, "<S:start-revision>%ld" |
| "</S:start-revision>", start)); |
| svn_stringbuf_appendcstr(request_body, |
| apr_psprintf(ras->pool, "<S:end-revision>%ld" |
| "</S:end-revision>", end)); |
| if (discover_changed_paths) |
| { |
| svn_stringbuf_appendcstr(request_body, |
| apr_psprintf(ras->pool, |
| "<S:discover-changed-paths/>")); |
| } |
| |
| for (i = 0; i < paths->nelts; i++) |
| { |
| const char *this_path = (((svn_stringbuf_t **)paths->elts)[i])->data; |
| /* ### todo: want to xml-escape the path, but can't use |
| apr_xml_quote_string() here because we don't use apr_util |
| yet. Should use svn_xml_escape_blah() instead? */ |
| svn_stringbuf_appendcstr(request_body, |
| apr_psprintf(ras->pool, |
| "<S:path>%s</S:path>", this_path)); |
| } |
| |
| svn_stringbuf_appendcstr(request_body, log_request_tail); |
| |
| lb.receiver = receiver; |
| lb.receiver_baton = receiver_baton; |
| lb.subpool = svn_pool_create (ras->pool); |
| reset_log_item (&lb); |
| |
| SVN_ERR( svn_ra_dav__parsed_request(ras, |
| "REPORT", |
| ras->root.path, |
| request_body->data, |
| 0, /* ignored */ |
| log_report_elements, |
| log_validate, |
| log_start_element, |
| log_end_element, |
| &lb, |
| ras->pool) ); |
| |
| svn_pool_destroy (lb.subpool); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| /* |
| * local variables: |
| * eval: (load-file "../../tools/dev/svn-dev.el") |
| * end: |
| */ |
