1 /*
2 * tree_conflicts.c: Storage of tree conflict descriptions in the WC.
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 #include "svn_dirent_uri.h"
25 #include "svn_path.h"
26 #include "svn_types.h"
27 #include "svn_pools.h"
28
29 #include "tree_conflicts.h"
30 #include "conflicts.h"
31 #include "wc.h"
32
33 #include "private/svn_skel.h"
34 #include "private/svn_wc_private.h"
35 #include "private/svn_token.h"
36
37 #include "svn_private_config.h"
38
39 /* ### this should move to a more general location... */
40 /* A map for svn_node_kind_t values. */
41 /* FIXME: this mapping defines a different representation of
42 svn_node_unknown than the one defined in token-map.h */
43 static const svn_token_map_t node_kind_map[] =
44 {
45 { "none", svn_node_none },
46 { "file", svn_node_file },
47 { "dir", svn_node_dir },
48 { "", svn_node_unknown },
49 /* ### should also map svn_node_symlink */
50 { NULL }
51 };
52
53 /* A map for svn_wc_operation_t values. */
54 const svn_token_map_t svn_wc__operation_map[] =
55 {
56 { "none", svn_wc_operation_none },
57 { "update", svn_wc_operation_update },
58 { "switch", svn_wc_operation_switch },
59 { "merge", svn_wc_operation_merge },
60 { NULL }
61 };
62
63 /* A map for svn_wc_conflict_action_t values. */
64 const svn_token_map_t svn_wc__conflict_action_map[] =
65 {
66 { "edited", svn_wc_conflict_action_edit },
67 { "deleted", svn_wc_conflict_action_delete },
68 { "added", svn_wc_conflict_action_add },
69 { "replaced", svn_wc_conflict_action_replace },
70 { NULL }
71 };
72
73 /* A map for svn_wc_conflict_reason_t values. */
74 const svn_token_map_t svn_wc__conflict_reason_map[] =
75 {
76 { "edited", svn_wc_conflict_reason_edited },
77 { "deleted", svn_wc_conflict_reason_deleted },
78 { "missing", svn_wc_conflict_reason_missing },
79 { "obstructed", svn_wc_conflict_reason_obstructed },
80 { "added", svn_wc_conflict_reason_added },
81 { "replaced", svn_wc_conflict_reason_replaced },
82 { "unversioned", svn_wc_conflict_reason_unversioned },
83 { "moved-away", svn_wc_conflict_reason_moved_away },
84 { "moved-here", svn_wc_conflict_reason_moved_here },
85 { NULL }
86 };
87
88
89 /* */
90 static svn_boolean_t
is_valid_version_info_skel(const svn_skel_t * skel)91 is_valid_version_info_skel(const svn_skel_t *skel)
92 {
93 return (svn_skel__list_length(skel) == 5
94 && svn_skel__matches_atom(skel->children, "version")
95 && skel->children->next->is_atom
96 && skel->children->next->next->is_atom
97 && skel->children->next->next->next->is_atom
98 && skel->children->next->next->next->next->is_atom);
99 }
100
101
102 /* */
103 static svn_boolean_t
is_valid_conflict_skel(const svn_skel_t * skel)104 is_valid_conflict_skel(const svn_skel_t *skel)
105 {
106 int i;
107
108 if (svn_skel__list_length(skel) != 8
109 || !svn_skel__matches_atom(skel->children, "conflict"))
110 return FALSE;
111
112 /* 5 atoms ... */
113 skel = skel->children->next;
114 for (i = 5; i--; skel = skel->next)
115 if (!skel->is_atom)
116 return FALSE;
117
118 /* ... and 2 version info skels. */
119 return (is_valid_version_info_skel(skel)
120 && is_valid_version_info_skel(skel->next));
121 }
122
123
124 /* Parse the enumeration value in VALUE into a plain
125 * 'int', using MAP to convert from strings to enumeration values.
126 * In MAP, a null .str field marks the end of the map.
127 */
128 static svn_error_t *
read_enum_field(int * result,const svn_token_map_t * map,const svn_skel_t * skel)129 read_enum_field(int *result,
130 const svn_token_map_t *map,
131 const svn_skel_t *skel)
132 {
133 int value = svn_token__from_mem(map, skel->data, skel->len);
134
135 if (value == SVN_TOKEN_UNKNOWN)
136 return svn_error_create(SVN_ERR_WC_CORRUPT, NULL,
137 _("Unknown enumeration value in tree conflict "
138 "description"));
139
140 *result = value;
141
142 return SVN_NO_ERROR;
143 }
144
145
146 /* Parse the conflict info fields from SKEL into *VERSION_INFO. */
147 static svn_error_t *
read_node_version_info(const svn_wc_conflict_version_t ** version_info,const svn_skel_t * skel,apr_pool_t * result_pool,apr_pool_t * scratch_pool)148 read_node_version_info(const svn_wc_conflict_version_t **version_info,
149 const svn_skel_t *skel,
150 apr_pool_t *result_pool,
151 apr_pool_t *scratch_pool)
152 {
153 int n;
154 const char *repos_root;
155 const char *repos_relpath;
156 svn_revnum_t peg_rev;
157 svn_node_kind_t kind;
158
159 if (!is_valid_version_info_skel(skel))
160 return svn_error_create(SVN_ERR_WC_CORRUPT, NULL,
161 _("Invalid version info in tree conflict "
162 "description"));
163
164 repos_root = apr_pstrmemdup(scratch_pool,
165 skel->children->next->data,
166 skel->children->next->len);
167 if (*repos_root == '\0')
168 {
169 *version_info = NULL;
170 return SVN_NO_ERROR;
171 }
172
173 /* Apply the Subversion 1.7+ url canonicalization rules to a pre 1.7 url */
174 repos_root = svn_uri_canonicalize(repos_root, result_pool);
175
176 peg_rev = SVN_STR_TO_REV(apr_pstrmemdup(scratch_pool,
177 skel->children->next->next->data,
178 skel->children->next->next->len));
179
180 repos_relpath = apr_pstrmemdup(result_pool,
181 skel->children->next->next->next->data,
182 skel->children->next->next->next->len);
183
184 SVN_ERR(read_enum_field(&n, node_kind_map,
185 skel->children->next->next->next->next));
186 kind = (svn_node_kind_t)n;
187
188 *version_info = svn_wc_conflict_version_create2(repos_root,
189 NULL,
190 repos_relpath,
191 peg_rev,
192 kind,
193 result_pool);
194
195 return SVN_NO_ERROR;
196 }
197
198
199 svn_error_t *
svn_wc__deserialize_conflict(const svn_wc_conflict_description2_t ** conflict,const svn_skel_t * skel,const char * dir_path,apr_pool_t * result_pool,apr_pool_t * scratch_pool)200 svn_wc__deserialize_conflict(const svn_wc_conflict_description2_t **conflict,
201 const svn_skel_t *skel,
202 const char *dir_path,
203 apr_pool_t *result_pool,
204 apr_pool_t *scratch_pool)
205 {
206 const char *victim_basename;
207 const char *victim_abspath;
208 svn_node_kind_t node_kind;
209 svn_wc_operation_t operation;
210 svn_wc_conflict_action_t action;
211 svn_wc_conflict_reason_t reason;
212 const svn_wc_conflict_version_t *src_left_version;
213 const svn_wc_conflict_version_t *src_right_version;
214 int n;
215 svn_wc_conflict_description2_t *new_conflict;
216
217 if (!is_valid_conflict_skel(skel))
218 return svn_error_createf(SVN_ERR_WC_CORRUPT, NULL,
219 _("Invalid conflict info '%s' in tree conflict "
220 "description"),
221 skel ? svn_skel__unparse(skel, scratch_pool)->data
222 : "(null)");
223
224 /* victim basename */
225 victim_basename = apr_pstrmemdup(scratch_pool,
226 skel->children->next->data,
227 skel->children->next->len);
228 if (victim_basename[0] == '\0')
229 return svn_error_create(SVN_ERR_WC_CORRUPT, NULL,
230 _("Empty 'victim' field in tree conflict "
231 "description"));
232
233 /* node_kind */
234 SVN_ERR(read_enum_field(&n, node_kind_map, skel->children->next->next));
235 node_kind = (svn_node_kind_t)n;
236 if (node_kind != svn_node_file && node_kind != svn_node_dir)
237 return svn_error_create(SVN_ERR_WC_CORRUPT, NULL,
238 _("Invalid 'node_kind' field in tree conflict description"));
239
240 /* operation */
241 SVN_ERR(read_enum_field(&n, svn_wc__operation_map,
242 skel->children->next->next->next));
243 operation = (svn_wc_operation_t)n;
244
245 SVN_ERR(svn_dirent_get_absolute(&victim_abspath,
246 svn_dirent_join(dir_path, victim_basename, scratch_pool),
247 scratch_pool));
248
249 /* action */
250 SVN_ERR(read_enum_field(&n, svn_wc__conflict_action_map,
251 skel->children->next->next->next->next));
252 action = n;
253
254 /* reason */
255 SVN_ERR(read_enum_field(&n, svn_wc__conflict_reason_map,
256 skel->children->next->next->next->next->next));
257 reason = n;
258
259 /* Let's just make it a bit easier on ourself here... */
260 skel = skel->children->next->next->next->next->next->next;
261
262 /* src_left_version */
263 SVN_ERR(read_node_version_info(&src_left_version, skel,
264 result_pool, scratch_pool));
265
266 /* src_right_version */
267 SVN_ERR(read_node_version_info(&src_right_version, skel->next,
268 result_pool, scratch_pool));
269
270 new_conflict = svn_wc_conflict_description_create_tree2(victim_abspath,
271 node_kind, operation, src_left_version, src_right_version,
272 result_pool);
273 new_conflict->action = action;
274 new_conflict->reason = reason;
275
276 *conflict = new_conflict;
277
278 return SVN_NO_ERROR;
279 }
280
281
282 /* Prepend to SKEL the string corresponding to enumeration value N, as found
283 * in MAP. */
284 static void
skel_prepend_enum(svn_skel_t * skel,const svn_token_map_t * map,int n,apr_pool_t * result_pool)285 skel_prepend_enum(svn_skel_t *skel,
286 const svn_token_map_t *map,
287 int n,
288 apr_pool_t *result_pool)
289 {
290 svn_skel__prepend(svn_skel__str_atom(svn_token__to_word(map, n),
291 result_pool), skel);
292 }
293
294
295 /* Prepend to PARENT_SKEL the several fields that represent VERSION_INFO, */
296 static svn_error_t *
prepend_version_info_skel(svn_skel_t * parent_skel,const svn_wc_conflict_version_t * version_info,apr_pool_t * pool)297 prepend_version_info_skel(svn_skel_t *parent_skel,
298 const svn_wc_conflict_version_t *version_info,
299 apr_pool_t *pool)
300 {
301 svn_skel_t *skel = svn_skel__make_empty_list(pool);
302
303 /* node_kind */
304 skel_prepend_enum(skel, node_kind_map, version_info->node_kind, pool);
305
306 /* path_in_repos */
307 svn_skel__prepend(svn_skel__str_atom(version_info->path_in_repos
308 ? version_info->path_in_repos
309 : "", pool), skel);
310
311 /* peg_rev */
312 svn_skel__prepend(svn_skel__str_atom(apr_psprintf(pool, "%ld",
313 version_info->peg_rev),
314 pool), skel);
315
316 /* repos_url */
317 svn_skel__prepend(svn_skel__str_atom(version_info->repos_url
318 ? version_info->repos_url
319 : "", pool), skel);
320
321 svn_skel__prepend(svn_skel__str_atom("version", pool), skel);
322
323 SVN_ERR_ASSERT(is_valid_version_info_skel(skel));
324
325 svn_skel__prepend(skel, parent_skel);
326
327 return SVN_NO_ERROR;
328 }
329
330
331 svn_error_t *
svn_wc__serialize_conflict(svn_skel_t ** skel,const svn_wc_conflict_description2_t * conflict,apr_pool_t * result_pool,apr_pool_t * scratch_pool)332 svn_wc__serialize_conflict(svn_skel_t **skel,
333 const svn_wc_conflict_description2_t *conflict,
334 apr_pool_t *result_pool,
335 apr_pool_t *scratch_pool)
336 {
337 /* A conflict version struct with all fields null/invalid. */
338 static const svn_wc_conflict_version_t null_version = {
339 NULL, SVN_INVALID_REVNUM, NULL, svn_node_unknown };
340 svn_skel_t *c_skel = svn_skel__make_empty_list(result_pool);
341 const char *victim_basename;
342
343 /* src_right_version */
344 if (conflict->src_right_version)
345 SVN_ERR(prepend_version_info_skel(c_skel, conflict->src_right_version,
346 result_pool));
347 else
348 SVN_ERR(prepend_version_info_skel(c_skel, &null_version, result_pool));
349
350 /* src_left_version */
351 if (conflict->src_left_version)
352 SVN_ERR(prepend_version_info_skel(c_skel, conflict->src_left_version,
353 result_pool));
354 else
355 SVN_ERR(prepend_version_info_skel(c_skel, &null_version, result_pool));
356
357 /* local change */
358 skel_prepend_enum(c_skel, svn_wc__conflict_reason_map,
359 conflict->reason, result_pool);
360
361 /* incoming change */
362 skel_prepend_enum(c_skel, svn_wc__conflict_action_map,
363 conflict->action, result_pool);
364
365 /* operation */
366 skel_prepend_enum(c_skel, svn_wc__operation_map, conflict->operation,
367 result_pool);
368
369 /* node_kind */
370 SVN_ERR_ASSERT(conflict->node_kind == svn_node_dir
371 || conflict->node_kind == svn_node_file
372 || conflict->node_kind == svn_node_none);
373 skel_prepend_enum(c_skel, node_kind_map, conflict->node_kind,
374 result_pool);
375
376 /* Victim path (escaping separator chars). */
377 victim_basename = svn_dirent_basename(conflict->local_abspath, result_pool);
378 SVN_ERR_ASSERT(victim_basename[0]);
379 svn_skel__prepend(svn_skel__str_atom(victim_basename, result_pool), c_skel);
380
381 svn_skel__prepend(svn_skel__str_atom("conflict", result_pool), c_skel);
382
383 SVN_ERR_ASSERT(is_valid_conflict_skel(c_skel));
384
385 *skel = c_skel;
386
387 return SVN_NO_ERROR;
388 }
389
390
391 svn_error_t *
svn_wc__del_tree_conflict(svn_wc_context_t * wc_ctx,const char * victim_abspath,apr_pool_t * scratch_pool)392 svn_wc__del_tree_conflict(svn_wc_context_t *wc_ctx,
393 const char *victim_abspath,
394 apr_pool_t *scratch_pool)
395 {
396 SVN_ERR_ASSERT(svn_dirent_is_absolute(victim_abspath));
397
398 SVN_ERR(svn_wc__db_op_mark_resolved(wc_ctx->db, victim_abspath,
399 FALSE, FALSE, TRUE, NULL,
400 scratch_pool));
401
402 return SVN_NO_ERROR;
403 }
404
405 svn_error_t *
svn_wc__add_tree_conflict(svn_wc_context_t * wc_ctx,const svn_wc_conflict_description2_t * conflict,apr_pool_t * scratch_pool)406 svn_wc__add_tree_conflict(svn_wc_context_t *wc_ctx,
407 const svn_wc_conflict_description2_t *conflict,
408 apr_pool_t *scratch_pool)
409 {
410 svn_boolean_t existing_conflict;
411 svn_skel_t *conflict_skel;
412 svn_error_t *err;
413
414 SVN_ERR_ASSERT(conflict != NULL);
415 SVN_ERR_ASSERT(conflict->operation == svn_wc_operation_merge ||
416 (conflict->reason != svn_wc_conflict_reason_moved_away &&
417 conflict->reason != svn_wc_conflict_reason_moved_here));
418
419 /* Re-adding an existing tree conflict victim is an error. */
420 err = svn_wc__internal_conflicted_p(NULL, NULL, &existing_conflict,
421 wc_ctx->db, conflict->local_abspath,
422 scratch_pool);
423 if (err)
424 {
425 if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND)
426 return svn_error_trace(err);
427
428 svn_error_clear(err);
429 }
430 else if (existing_conflict)
431 return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL,
432 _("Attempt to add tree conflict that already "
433 "exists at '%s'"),
434 svn_dirent_local_style(conflict->local_abspath,
435 scratch_pool));
436 else if (!conflict)
437 return SVN_NO_ERROR;
438
439 conflict_skel = svn_wc__conflict_skel_create(scratch_pool);
440
441 SVN_ERR(svn_wc__conflict_skel_add_tree_conflict(conflict_skel, wc_ctx->db,
442 conflict->local_abspath,
443 conflict->reason,
444 conflict->action,
445 NULL, NULL,
446 scratch_pool, scratch_pool));
447
448 switch (conflict->operation)
449 {
450 case svn_wc_operation_update:
451 default:
452 SVN_ERR(svn_wc__conflict_skel_set_op_update(conflict_skel,
453 conflict->src_left_version,
454 conflict->src_right_version,
455 scratch_pool, scratch_pool));
456 break;
457 case svn_wc_operation_switch:
458 SVN_ERR(svn_wc__conflict_skel_set_op_switch(conflict_skel,
459 conflict->src_left_version,
460 conflict->src_right_version,
461 scratch_pool, scratch_pool));
462 break;
463 case svn_wc_operation_merge:
464 SVN_ERR(svn_wc__conflict_skel_set_op_merge(conflict_skel,
465 conflict->src_left_version,
466 conflict->src_right_version,
467 scratch_pool, scratch_pool));
468 break;
469 }
470
471 return svn_error_trace(
472 svn_wc__db_op_mark_conflict(wc_ctx->db, conflict->local_abspath,
473 conflict_skel, NULL, scratch_pool));
474 }
475
476
477 svn_error_t *
svn_wc__get_tree_conflict(const svn_wc_conflict_description2_t ** tree_conflict,svn_wc_context_t * wc_ctx,const char * local_abspath,apr_pool_t * result_pool,apr_pool_t * scratch_pool)478 svn_wc__get_tree_conflict(const svn_wc_conflict_description2_t **tree_conflict,
479 svn_wc_context_t *wc_ctx,
480 const char *local_abspath,
481 apr_pool_t *result_pool,
482 apr_pool_t *scratch_pool)
483 {
484 const apr_array_header_t *conflicts;
485 int i;
486 SVN_ERR_ASSERT(svn_dirent_is_absolute(local_abspath));
487
488 SVN_ERR(svn_wc__read_conflicts(&conflicts, NULL,
489 wc_ctx->db, local_abspath,
490 FALSE /* temp files */,
491 TRUE /* only tree conflicts */,
492 scratch_pool, scratch_pool));
493
494 if (!conflicts || conflicts->nelts == 0)
495 {
496 *tree_conflict = NULL;
497 return SVN_NO_ERROR;
498 }
499
500 for (i = 0; i < conflicts->nelts; i++)
501 {
502 const svn_wc_conflict_description2_t *desc;
503
504 desc = APR_ARRAY_IDX(conflicts, i, svn_wc_conflict_description2_t *);
505
506 if (desc->kind == svn_wc_conflict_kind_tree)
507 {
508 *tree_conflict = svn_wc_conflict_description2_dup(desc, result_pool);
509 return SVN_NO_ERROR;
510 }
511 }
512
513 *tree_conflict = NULL;
514 return SVN_NO_ERROR;
515 }
516
517