contrib/subversion/subversion/libsvn_ra_serf/merge.c

   1 /*
   2  * merge.c :  MERGE response parsing functions for ra_serf
   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
  25 \f
  26 #include <apr_uri.h>
  27
  28 #include <serf.h>
  29
  30 #include "svn_hash.h"
  31 #include "svn_pools.h"
  32 #include "svn_ra.h"
  33 #include "svn_dav.h"
  34 #include "svn_xml.h"
  35 #include "svn_config.h"
  36 #include "svn_dirent_uri.h"
  37 #include "svn_props.h"
  38
  39 #include "private/svn_dav_protocol.h"
  40 #include "private/svn_fspath.h"
  41 #include "svn_private_config.h"
  42
  43 #include "ra_serf.h"
  44 #include "../libsvn_ra/ra_loader.h"
  45
  46 \f
  47 /*
  48  * This enum represents the current state of our XML parsing for a MERGE.
  49  */
  50 typedef enum merge_state_e {
  51   INITIAL = XML_STATE_INITIAL,
  52   MERGE_RESPONSE,
  53   UPDATED_SET,
  54   RESPONSE,
  55   HREF,
  56   PROPSTAT,
  57   PROP,
  58   RESOURCE_TYPE,
  59   BASELINE,
  60   COLLECTION,
  61   SKIP_HREF,
  62   CHECKED_IN,
  63   VERSION_NAME,
  64   DATE,
  65   AUTHOR,
  66   POST_COMMIT_ERR,
  67
  68   STATUS
  69 } merge_state_e;
  70
  71
  72 /* Structure associated with a MERGE request. */
  73 typedef struct merge_context_t
  74 {
  75   apr_pool_t *pool;
  76
  77   svn_ra_serf__session_t *session;
  78   svn_ra_serf__handler_t *handler;
  79
  80   apr_hash_t *lock_tokens;
  81   svn_boolean_t keep_locks;
  82
  83   const char *merge_resource_url; /* URL of resource to be merged. */
  84   const char *merge_url; /* URL at which the MERGE request is aimed. */
  85
  86   svn_commit_info_t *commit_info;
  87
  88 } merge_context_t;
  89
  90
  91 #define D_ "DAV:"
  92 #define S_ SVN_XML_NAMESPACE
  93 static const svn_ra_serf__xml_transition_t merge_ttable[] = {
  94   { INITIAL, D_, "merge-response", MERGE_RESPONSE,
  95     FALSE, { NULL }, FALSE },
  96
  97   { MERGE_RESPONSE, D_, "updated-set", UPDATED_SET,
  98     FALSE, { NULL }, FALSE },
  99
 100   { UPDATED_SET, D_, "response", RESPONSE,
 101     FALSE, { NULL }, TRUE },
 102
 103   { RESPONSE, D_, "href", HREF,
 104     TRUE, { NULL }, TRUE },
 105
 106   { RESPONSE, D_, "propstat", PROPSTAT,
 107     FALSE, { NULL }, FALSE },
 108
 109 #if 0
 110   /* Not needed.  */
 111   { PROPSTAT, D_, "status", STATUS,
 112     FALSE, { NULL }, FALSE },
 113 #endif
 114
 115   { PROPSTAT, D_, "prop", PROP,
 116     FALSE, { NULL }, FALSE },
 117
 118   { PROP, D_, "resourcetype", RESOURCE_TYPE,
 119     FALSE, { NULL }, FALSE },
 120
 121   { RESOURCE_TYPE, D_, "baseline", BASELINE,
 122     FALSE, { NULL }, TRUE },
 123
 124   { RESOURCE_TYPE, D_, "collection", COLLECTION,
 125     FALSE, { NULL }, TRUE },
 126
 127   { PROP, D_, "checked-in", SKIP_HREF,
 128     FALSE, { NULL }, FALSE },
 129
 130   { SKIP_HREF, D_, "href", CHECKED_IN,
 131     TRUE, { NULL }, TRUE },
 132
 133   { PROP, D_, SVN_DAV__VERSION_NAME, VERSION_NAME,
 134     TRUE, { NULL }, TRUE },
 135
 136   { PROP, D_, SVN_DAV__CREATIONDATE, DATE,
 137     TRUE, { NULL }, TRUE },
 138
 139   { PROP, D_, "creator-displayname", AUTHOR,
 140     TRUE, { NULL }, TRUE },
 141
 142   { PROP, S_, "post-commit-err", POST_COMMIT_ERR,
 143     TRUE, { NULL }, TRUE },
 144
 145   { 0 }
 146 };
 147
 148
 149 /* Conforms to svn_ra_serf__xml_closed_t  */
 150 static svn_error_t *
 151 merge_closed(svn_ra_serf__xml_estate_t *xes,
 152              void *baton,
 153              int leaving_state,
 154              const svn_string_t *cdata,
 155              apr_hash_t *attrs,
 156              apr_pool_t *scratch_pool)
 157 {
 158   merge_context_t *merge_ctx = baton;
 159
 160   if (leaving_state == RESPONSE)
 161     {
 162       const char *rtype;
 163
 164       rtype = svn_hash_gets(attrs, "resourcetype");
 165
 166       /* rtype can only be "baseline" or "collection" (or NULL). We can
 167          keep this check simple.  */
 168       if (rtype && *rtype == 'b')
 169         {
 170           const char *rev_str;
 171
 172           rev_str = svn_hash_gets(attrs, "revision");
 173           if (rev_str)
 174             {
 175               apr_int64_t rev;
 176
 177               SVN_ERR(svn_cstring_atoi64(&rev, rev_str));
 178               merge_ctx->commit_info->revision = (svn_revnum_t)rev;
 179             }
 180           else
 181             merge_ctx->commit_info->revision = SVN_INVALID_REVNUM;
 182
 183           merge_ctx->commit_info->date =
 184               apr_pstrdup(merge_ctx->pool,
 185                           svn_hash_gets(attrs, "date"));
 186
 187           merge_ctx->commit_info->author =
 188               apr_pstrdup(merge_ctx->pool,
 189                           svn_hash_gets(attrs, "author"));
 190
 191           merge_ctx->commit_info->post_commit_err =
 192              apr_pstrdup(merge_ctx->pool,
 193                          svn_hash_gets(attrs, "post-commit-err"));
 194         }
 195       else
 196         {
 197           const char *href;
 198
 199           href = svn_urlpath__skip_ancestor(
 200                    merge_ctx->merge_url,
 201                    svn_hash_gets(attrs, "href"));
 202
 203           if (href == NULL)
 204             return svn_error_createf(SVN_ERR_RA_DAV_REQUEST_FAILED, NULL,
 205                                      _("A MERGE response for '%s' is not "
 206                                        "a child of the destination ('%s')"),
 207                                      href, merge_ctx->merge_url);
 208
 209           /* We now need to dive all the way into the WC to update the
 210              base VCC url.  */
 211           if (!SVN_RA_SERF__HAVE_HTTPV2_SUPPORT(merge_ctx->session)
 212               && merge_ctx->session->wc_callbacks->push_wc_prop)
 213             {
 214               const char *checked_in;
 215               svn_string_t checked_in_str;
 216
 217               checked_in = svn_hash_gets(attrs, "checked-in");
 218               checked_in_str.data = checked_in;
 219               checked_in_str.len = strlen(checked_in);
 220
 221               SVN_ERR(merge_ctx->session->wc_callbacks->push_wc_prop(
 222                         merge_ctx->session->wc_callback_baton,
 223                         href,
 224                         SVN_RA_SERF__WC_CHECKED_IN_URL,
 225                         &checked_in_str,
 226                         scratch_pool));
 227             }
 228         }
 229     }
 230   else if (leaving_state == BASELINE)
 231     {
 232       svn_ra_serf__xml_note(xes, RESPONSE, "resourcetype", "baseline");
 233     }
 234   else if (leaving_state == COLLECTION)
 235     {
 236       svn_ra_serf__xml_note(xes, RESPONSE, "resourcetype", "collection");
 237     }
 238   else
 239     {
 240       const char *name;
 241       const char *value = cdata->data;
 242
 243       if (leaving_state == HREF)
 244         {
 245           name = "href";
 246           value = svn_urlpath__canonicalize(value, scratch_pool);
 247         }
 248       else if (leaving_state == CHECKED_IN)
 249         {
 250           name = "checked-in";
 251           value = svn_urlpath__canonicalize(value, scratch_pool);
 252         }
 253       else if (leaving_state == VERSION_NAME)
 254         name = "revision";
 255       else if (leaving_state == DATE)
 256         name = "date";
 257       else if (leaving_state == AUTHOR)
 258         name = "author";
 259       else if (leaving_state == POST_COMMIT_ERR)
 260         name = "post-commit-err";
 261       else
 262         SVN_ERR_MALFUNCTION();
 263
 264       svn_ra_serf__xml_note(xes, RESPONSE, name, value);
 265     }
 266
 267   return SVN_NO_ERROR;
 268 }
 269
 270
 271 static svn_error_t *
 272 setup_merge_headers(serf_bucket_t *headers,
 273                     void *baton,
 274                     apr_pool_t *pool /* request pool */,
 275                     apr_pool_t *scratch_pool)
 276 {
 277   merge_context_t *ctx = baton;
 278
 279   if (!ctx->keep_locks)
 280     {
 281       serf_bucket_headers_set(headers, SVN_DAV_OPTIONS_HEADER,
 282                               SVN_DAV_OPTION_RELEASE_LOCKS);
 283     }
 284
 285   return SVN_NO_ERROR;
 286 }
 287
 288 void
 289 svn_ra_serf__merge_lock_token_list(apr_hash_t *lock_tokens,
 290                                    const char *parent,
 291                                    serf_bucket_t *body,
 292                                    serf_bucket_alloc_t *alloc,
 293                                    apr_pool_t *pool)
 294 {
 295   apr_hash_index_t *hi;
 296
 297   if (!lock_tokens || apr_hash_count(lock_tokens) == 0)
 298     return;
 299
 300   svn_ra_serf__add_open_tag_buckets(body, alloc,
 301                                     "S:lock-token-list",
 302                                     "xmlns:S", SVN_XML_NAMESPACE,
 303                                     SVN_VA_NULL);
 304
 305   for (hi = apr_hash_first(pool, lock_tokens);
 306        hi;
 307        hi = apr_hash_next(hi))
 308     {
 309       const void *key;
 310       apr_ssize_t klen;
 311       void *val;
 312       svn_string_t path;
 313
 314       apr_hash_this(hi, &key, &klen, &val);
 315
 316       path.data = key;
 317       path.len = klen;
 318
 319       if (parent && !svn_relpath_skip_ancestor(parent, key))
 320         continue;
 321
 322       svn_ra_serf__add_open_tag_buckets(body, alloc, "S:lock", SVN_VA_NULL);
 323
 324       svn_ra_serf__add_open_tag_buckets(body, alloc, "lock-path", SVN_VA_NULL);
 325       svn_ra_serf__add_cdata_len_buckets(body, alloc, path.data, path.len);
 326       svn_ra_serf__add_close_tag_buckets(body, alloc, "lock-path");
 327
 328       svn_ra_serf__add_tag_buckets(body, "lock-token", val, alloc);
 329
 330       svn_ra_serf__add_close_tag_buckets(body, alloc, "S:lock");
 331     }
 332
 333   svn_ra_serf__add_close_tag_buckets(body, alloc, "S:lock-token-list");
 334 }
 335
 336 /* Implements svn_ra_serf__request_body_delegate_t */
 337 static svn_error_t*
 338 create_merge_body(serf_bucket_t **bkt,
 339                   void *baton,
 340                   serf_bucket_alloc_t *alloc,
 341                   apr_pool_t *pool /* request pool */,
 342                   apr_pool_t *scratch_pool)
 343 {
 344   merge_context_t *ctx = baton;
 345   serf_bucket_t *body_bkt;
 346
 347   body_bkt = serf_bucket_aggregate_create(alloc);
 348
 349   svn_ra_serf__add_xml_header_buckets(body_bkt, alloc);
 350   svn_ra_serf__add_open_tag_buckets(body_bkt, alloc, "D:merge",
 351                                     "xmlns:D", "DAV:",
 352                                     SVN_VA_NULL);
 353   svn_ra_serf__add_open_tag_buckets(body_bkt, alloc, "D:source", SVN_VA_NULL);
 354   svn_ra_serf__add_open_tag_buckets(body_bkt, alloc, "D:href", SVN_VA_NULL);
 355
 356   svn_ra_serf__add_cdata_len_buckets(body_bkt, alloc,
 357                                      ctx->merge_resource_url,
 358                                      strlen(ctx->merge_resource_url));
 359
 360   svn_ra_serf__add_close_tag_buckets(body_bkt, alloc, "D:href");
 361   svn_ra_serf__add_close_tag_buckets(body_bkt, alloc, "D:source");
 362
 363   svn_ra_serf__add_empty_tag_buckets(body_bkt, alloc,
 364                                      "D:no-auto-merge", SVN_VA_NULL);
 365   svn_ra_serf__add_empty_tag_buckets(body_bkt, alloc,
 366                                      "D:no-checkout", SVN_VA_NULL);
 367
 368   svn_ra_serf__add_open_tag_buckets(body_bkt, alloc, "D:prop", SVN_VA_NULL);
 369   svn_ra_serf__add_empty_tag_buckets(body_bkt, alloc,
 370                                      "D:checked-in", SVN_VA_NULL);
 371   svn_ra_serf__add_empty_tag_buckets(body_bkt, alloc,
 372                                      "D:" SVN_DAV__VERSION_NAME, SVN_VA_NULL);
 373   svn_ra_serf__add_empty_tag_buckets(body_bkt, alloc,
 374                                      "D:resourcetype", SVN_VA_NULL);
 375   svn_ra_serf__add_empty_tag_buckets(body_bkt, alloc,
 376                                      "D:" SVN_DAV__CREATIONDATE, SVN_VA_NULL);
 377   svn_ra_serf__add_empty_tag_buckets(body_bkt, alloc,
 378                                      "D:creator-displayname", SVN_VA_NULL);
 379   svn_ra_serf__add_close_tag_buckets(body_bkt, alloc, "D:prop");
 380
 381   svn_ra_serf__merge_lock_token_list(ctx->lock_tokens, NULL, body_bkt,
 382                                      alloc, pool);
 383
 384   svn_ra_serf__add_close_tag_buckets(body_bkt, alloc, "D:merge");
 385
 386   *bkt = body_bkt;
 387
 388   return SVN_NO_ERROR;
 389 }
 390
 391
 392 svn_error_t *
 393 svn_ra_serf__run_merge(const svn_commit_info_t **commit_info,
 394                        svn_ra_serf__session_t *session,
 395                        const char *merge_resource_url,
 396                        apr_hash_t *lock_tokens,
 397                        svn_boolean_t keep_locks,
 398                        apr_pool_t *result_pool,
 399                        apr_pool_t *scratch_pool)
 400 {
 401   merge_context_t *merge_ctx;
 402   svn_ra_serf__handler_t *handler;
 403   svn_ra_serf__xml_context_t *xmlctx;
 404
 405   merge_ctx = apr_pcalloc(scratch_pool, sizeof(*merge_ctx));
 406
 407   merge_ctx->pool = result_pool;
 408   merge_ctx->session = session;
 409
 410   merge_ctx->merge_resource_url = merge_resource_url;
 411
 412   merge_ctx->lock_tokens = lock_tokens;
 413   merge_ctx->keep_locks = keep_locks;
 414
 415   merge_ctx->commit_info = svn_create_commit_info(result_pool);
 416
 417   merge_ctx->merge_url = session->session_url.path;
 418
 419   xmlctx = svn_ra_serf__xml_context_create(merge_ttable,
 420                                            NULL, merge_closed, NULL,
 421                                            merge_ctx,
 422                                            scratch_pool);
 423   handler = svn_ra_serf__create_expat_handler(session, xmlctx, NULL,
 424                                               scratch_pool);
 425
 426   handler->method = "MERGE";
 427   handler->path = merge_ctx->merge_url;
 428   handler->body_delegate = create_merge_body;
 429   handler->body_delegate_baton = merge_ctx;
 430   handler->body_type = "text/xml";
 431
 432   handler->header_delegate = setup_merge_headers;
 433   handler->header_delegate_baton = merge_ctx;
 434
 435   merge_ctx->handler = handler;
 436
 437   SVN_ERR(svn_ra_serf__context_run_one(handler, scratch_pool));
 438
 439   if (handler->sline.code != 200)
 440     return svn_error_trace(svn_ra_serf__unexpected_status(handler));
 441
 442   *commit_info = merge_ctx->commit_info;
 443
 444   /* Sanity check (Reported to be triggered by CodePlex's svnbridge) */
 445   if (! SVN_IS_VALID_REVNUM(merge_ctx->commit_info->revision))
 446     {
 447       return svn_error_create(SVN_ERR_RA_DAV_PROPS_NOT_FOUND, NULL,
 448                               _("The MERGE response did not include "
 449                                 "a new revision"));
 450     }
 451
 452   merge_ctx->commit_info->repos_root = apr_pstrdup(result_pool,
 453                                                    session->repos_root_str);
 454
 455   return SVN_NO_ERROR;
 456 }